home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.1B1 / AIncludes / LowMem.a < prev    next >
Encoding:
Text File  |  1995-04-18  |  74.2 KB  |  4,366 lines  |  [TEXT/MPS ]

  1. ;
  2. ;    File:        LowMem.a
  3. ;
  4. ;    Contains:    Low Memory Accessor Interfaces.
  5. ;
  6. ;    Version:    Technology:    System 7.5
  7. ;                Package:    Universal Interfaces 2.1ß1.1 in “MPW Prerelease” on ETO #17
  8. ;
  9. ;    Copyright:    © 1984-1995 by Apple Computer, Inc.
  10. ;                All rights reserved.
  11. ;
  12. ;    Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13. ;                stack.  Include the file and version information (from above)
  14. ;                in the problem description and send to:
  15. ;                    Internet:    apple.bugs@applelink.apple.com
  16. ;                    AppleLink:    APPLE.BUGS
  17. ;
  18. ;
  19.  
  20.     IF &TYPE('__LOWMEM__') = 'UNDEFINED' THEN
  21. __LOWMEM__ SET 1
  22.  
  23.  
  24.     IF &TYPE('__TYPES__') = 'UNDEFINED' THEN
  25.     include 'Types.a'
  26.     ENDIF
  27. ;        include 'ConditionalMacros.a'                                ;
  28.  
  29.     IF &TYPE('__CONTROLS__') = 'UNDEFINED' THEN
  30.     include 'Controls.a'
  31.     ENDIF
  32. ;        include 'Quickdraw.a'                                        ;
  33. ;            include 'MixedMode.a'                                    ;
  34. ;            include 'QuickdrawText.a'                                ;
  35. ;        include 'Menus.a'                                            ;
  36. ;            include 'Memory.a'                                        ;
  37.  
  38.     IF &TYPE('__EVENTS__') = 'UNDEFINED' THEN
  39.     include 'Events.a'
  40.     ENDIF
  41. ;        include 'OSUtils.a'                                        ;
  42.  
  43.     IF &TYPE('__FILES__') = 'UNDEFINED' THEN
  44.     include 'Files.a'
  45.     ENDIF
  46.  
  47.     IF &TYPE('__FONTS__') = 'UNDEFINED' THEN
  48.     include 'Fonts.a'
  49.     ENDIF
  50.  
  51.     IF &TYPE('__MEMORY__') = 'UNDEFINED' THEN
  52.     include 'Memory.a'
  53.     ENDIF
  54.  
  55.     IF &TYPE('__MENUS__') = 'UNDEFINED' THEN
  56.     include 'Menus.a'
  57.     ENDIF
  58.  
  59.     IF &TYPE('__OSUTILS__') = 'UNDEFINED' THEN
  60.     include 'OSUtils.a'
  61.     ENDIF
  62.  
  63.     IF &TYPE('__QUICKDRAW__') = 'UNDEFINED' THEN
  64.     include 'Quickdraw.a'
  65.     ENDIF
  66.  
  67.     IF &TYPE('__RESOURCES__') = 'UNDEFINED' THEN
  68.     include 'Resources.a'
  69.     ENDIF
  70.  
  71.     IF &TYPE('__WINDOWS__') = 'UNDEFINED' THEN
  72.     include 'Windows.a'
  73.     ENDIF
  74. ;
  75. ; pascal SInt16 LMGetScrVRes(void)
  76. ;
  77.     IF ¬ GENERATINGCFM THEN
  78.         Macro
  79.         _LMGetScrVRes        &dest=(sp)
  80.         move.w               $0102,&dest
  81.         EndM
  82.     ELSE
  83.         IMPORT_CFM_FUNCTION    LMGetScrVRes
  84.     ENDIF
  85.  
  86. ;
  87. ; pascal void LMSetScrVRes(SInt16 value)
  88. ;
  89.     IF ¬ GENERATINGCFM THEN
  90.         Macro
  91.         _LMSetScrVRes        &src=(sp)+
  92.         move.w               &src,$0102
  93.         EndM
  94.     ELSE
  95.         IMPORT_CFM_FUNCTION    LMSetScrVRes
  96.     ENDIF
  97.  
  98. ;
  99. ; pascal SInt16 LMGetScrHRes(void)
  100. ;
  101.     IF ¬ GENERATINGCFM THEN
  102.         Macro
  103.         _LMGetScrHRes        &dest=(sp)
  104.         move.w               $0104,&dest
  105.         EndM
  106.     ELSE
  107.         IMPORT_CFM_FUNCTION    LMGetScrHRes
  108.     ENDIF
  109.  
  110. ;
  111. ; pascal void LMSetScrHRes(SInt16 value)
  112. ;
  113.     IF ¬ GENERATINGCFM THEN
  114.         Macro
  115.         _LMSetScrHRes        &src=(sp)+
  116.         move.w               &src,$0104
  117.         EndM
  118.     ELSE
  119.         IMPORT_CFM_FUNCTION    LMSetScrHRes
  120.     ENDIF
  121.  
  122. ;
  123. ; pascal Ptr LMGetMemTop(void)
  124. ;
  125.     IF ¬ GENERATINGCFM THEN
  126.         Macro
  127.         _LMGetMemTop         &dest=(sp)
  128.         move.l               $0108,&dest
  129.         EndM
  130.     ELSE
  131.         IMPORT_CFM_FUNCTION    LMGetMemTop
  132.     ENDIF
  133.  
  134. ;
  135. ; pascal void LMSetMemTop(Ptr value)
  136. ;
  137.     IF ¬ GENERATINGCFM THEN
  138.         Macro
  139.         _LMSetMemTop         &src=(sp)+
  140.         move.l               &src,$0108
  141.         EndM
  142.     ELSE
  143.         IMPORT_CFM_FUNCTION    LMSetMemTop
  144.     ENDIF
  145.  
  146. ;
  147. ; pascal Ptr LMGetBufPtr(void)
  148. ;
  149.     IF ¬ GENERATINGCFM THEN
  150.         Macro
  151.         _LMGetBufPtr         &dest=(sp)
  152.         move.l               $010C,&dest
  153.         EndM
  154.     ELSE
  155.         IMPORT_CFM_FUNCTION    LMGetBufPtr
  156.     ENDIF
  157.  
  158. ;
  159. ; pascal void LMSetBufPtr(Ptr value)
  160. ;
  161.     IF ¬ GENERATINGCFM THEN
  162.         Macro
  163.         _LMSetBufPtr         &src=(sp)+
  164.         move.l               &src,$010C
  165.         EndM
  166.     ELSE
  167.         IMPORT_CFM_FUNCTION    LMSetBufPtr
  168.     ENDIF
  169.  
  170. ;
  171. ; pascal Ptr LMGetStackLowPoint(void)
  172. ;
  173.     IF ¬ GENERATINGCFM THEN
  174.         Macro
  175.         _LMGetStackLowPoint  &dest=(sp)
  176.         move.l               $0110,&dest
  177.         EndM
  178.     ELSE
  179.         IMPORT_CFM_FUNCTION    LMGetStackLowPoint
  180.     ENDIF
  181.  
  182. ;
  183. ; pascal void LMSetStackLowPoint(Ptr value)
  184. ;
  185.     IF ¬ GENERATINGCFM THEN
  186.         Macro
  187.         _LMSetStackLowPoint  &src=(sp)+
  188.         move.l               &src,$0110
  189.         EndM
  190.     ELSE
  191.         IMPORT_CFM_FUNCTION    LMSetStackLowPoint
  192.     ENDIF
  193.  
  194. ;
  195. ; pascal Ptr LMGetHeapEnd(void)
  196. ;
  197.     IF ¬ GENERATINGCFM THEN
  198.         Macro
  199.         _LMGetHeapEnd        &dest=(sp)
  200.         move.l               $0114,&dest
  201.         EndM
  202.     ELSE
  203.         IMPORT_CFM_FUNCTION    LMGetHeapEnd
  204.     ENDIF
  205.  
  206. ;
  207. ; pascal void LMSetHeapEnd(Ptr value)
  208. ;
  209.     IF ¬ GENERATINGCFM THEN
  210.         Macro
  211.         _LMSetHeapEnd        &src=(sp)+
  212.         move.l               &src,$0114
  213.         EndM
  214.     ELSE
  215.         IMPORT_CFM_FUNCTION    LMSetHeapEnd
  216.     ENDIF
  217.  
  218. ;
  219. ; pascal THz LMGetTheZone(void)
  220. ;
  221.     IF ¬ GENERATINGCFM THEN
  222.         Macro
  223.         _LMGetTheZone        &dest=(sp)
  224.         move.l               $0118,&dest
  225.         EndM
  226.     ELSE
  227.         IMPORT_CFM_FUNCTION    LMGetTheZone
  228.     ENDIF
  229.  
  230. ;
  231. ; pascal void LMSetTheZone(THz value)
  232. ;
  233.     IF ¬ GENERATINGCFM THEN
  234.         Macro
  235.         _LMSetTheZone        &src=(sp)+
  236.         move.l               &src,$0118
  237.         EndM
  238.     ELSE
  239.         IMPORT_CFM_FUNCTION    LMSetTheZone
  240.     ENDIF
  241.  
  242. ;
  243. ; pascal Ptr LMGetUTableBase(void)
  244. ;
  245.     IF ¬ GENERATINGCFM THEN
  246.         Macro
  247.         _LMGetUTableBase     &dest=(sp)
  248.         move.l               $011C,&dest
  249.         EndM
  250.     ELSE
  251.         IMPORT_CFM_FUNCTION    LMGetUTableBase
  252.     ENDIF
  253.  
  254. ;
  255. ; pascal void LMSetUTableBase(Ptr value)
  256. ;
  257.     IF ¬ GENERATINGCFM THEN
  258.         Macro
  259.         _LMSetUTableBase     &src=(sp)+
  260.         move.l               &src,$011C
  261.         EndM
  262.     ELSE
  263.         IMPORT_CFM_FUNCTION    LMSetUTableBase
  264.     ENDIF
  265.  
  266. ;
  267. ; pascal UInt8 LMGetCPUFlag(void)
  268. ;
  269.     IF ¬ GENERATINGCFM THEN
  270.         Macro
  271.         _LMGetCPUFlag        &dest=(sp)
  272.         move.b               $012F,&dest
  273.         EndM
  274.     ELSE
  275.         IMPORT_CFM_FUNCTION    LMGetCPUFlag
  276.     ENDIF
  277.  
  278. ;
  279. ; pascal void LMSetCPUFlag(UInt8 value)
  280. ;
  281.     IF ¬ GENERATINGCFM THEN
  282.         Macro
  283.         _LMSetCPUFlag        &src=(sp)+
  284.         move.b               &src,$012F
  285.         EndM
  286.     ELSE
  287.         IMPORT_CFM_FUNCTION    LMSetCPUFlag
  288.     ENDIF
  289.  
  290. ;
  291. ; pascal Ptr LMGetApplLimit(void)
  292. ;
  293.     IF ¬ GENERATINGCFM THEN
  294.         Macro
  295.         _LMGetApplLimit      &dest=(sp)
  296.         move.l               $0130,&dest
  297.         EndM
  298.     ELSE
  299.         IMPORT_CFM_FUNCTION    LMGetApplLimit
  300.     ENDIF
  301.  
  302. ;
  303. ; pascal void LMSetApplLimit(Ptr value)
  304. ;
  305.     IF ¬ GENERATINGCFM THEN
  306.         Macro
  307.         _LMSetApplLimit      &src=(sp)+
  308.         move.l               &src,$0130
  309.         EndM
  310.     ELSE
  311.         IMPORT_CFM_FUNCTION    LMSetApplLimit
  312.     ENDIF
  313.  
  314. ;
  315. ; pascal SInt16 LMGetSysEvtMask(void)
  316. ;
  317.     IF ¬ GENERATINGCFM THEN
  318.         Macro
  319.         _LMGetSysEvtMask     &dest=(sp)
  320.         move.w               $0144,&dest
  321.         EndM
  322.     ELSE
  323.         IMPORT_CFM_FUNCTION    LMGetSysEvtMask
  324.     ENDIF
  325.  
  326. ;
  327. ; pascal void LMSetSysEvtMask(SInt16 value)
  328. ;
  329.     IF ¬ GENERATINGCFM THEN
  330.         Macro
  331.         _LMSetSysEvtMask     &src=(sp)+
  332.         move.w               &src,$0144
  333.         EndM
  334.     ELSE
  335.         IMPORT_CFM_FUNCTION    LMSetSysEvtMask
  336.     ENDIF
  337.  
  338. ;
  339. ; pascal SInt32 LMGetRndSeed(void)
  340. ;
  341.     IF ¬ GENERATINGCFM THEN
  342.         Macro
  343.         _LMGetRndSeed        &dest=(sp)
  344.         move.l               $0156,&dest
  345.         EndM
  346.     ELSE
  347.         IMPORT_CFM_FUNCTION    LMGetRndSeed
  348.     ENDIF
  349.  
  350. ;
  351. ; pascal void LMSetRndSeed(SInt32 value)
  352. ;
  353.     IF ¬ GENERATINGCFM THEN
  354.         Macro
  355.         _LMSetRndSeed        &src=(sp)+
  356.         move.l               &src,$0156
  357.         EndM
  358.     ELSE
  359.         IMPORT_CFM_FUNCTION    LMSetRndSeed
  360.     ENDIF
  361.  
  362. ;
  363. ; pascal UInt8 LMGetSEvtEnb(void)
  364. ;
  365.     IF ¬ GENERATINGCFM THEN
  366.         Macro
  367.         _LMGetSEvtEnb        &dest=(sp)
  368.         move.b               $015C,&dest
  369.         EndM
  370.     ELSE
  371.         IMPORT_CFM_FUNCTION    LMGetSEvtEnb
  372.     ENDIF
  373.  
  374. ;
  375. ; pascal void LMSetSEvtEnb(UInt8 value)
  376. ;
  377.     IF ¬ GENERATINGCFM THEN
  378.         Macro
  379.         _LMSetSEvtEnb        &src=(sp)+
  380.         move.b               &src,$015C
  381.         EndM
  382.     ELSE
  383.         IMPORT_CFM_FUNCTION    LMSetSEvtEnb
  384.     ENDIF
  385.  
  386. ;
  387. ; pascal SInt32 LMGetTicks(void)
  388. ;
  389.     IF ¬ GENERATINGCFM THEN
  390.         Macro
  391.         _LMGetTicks          &dest=(sp)
  392.         move.l               $016A,&dest
  393.         EndM
  394.     ELSE
  395.         IMPORT_CFM_FUNCTION    LMGetTicks
  396.     ENDIF
  397.  
  398. ;
  399. ; pascal void LMSetTicks(SInt32 value)
  400. ;
  401.     IF ¬ GENERATINGCFM THEN
  402.         Macro
  403.         _LMSetTicks          &src=(sp)+
  404.         move.l               &src,$016A
  405.         EndM
  406.     ELSE
  407.         IMPORT_CFM_FUNCTION    LMSetTicks
  408.     ENDIF
  409.  
  410. ;
  411. ; pascal SInt16 LMGetKeyThresh(void)
  412. ;
  413.     IF ¬ GENERATINGCFM THEN
  414.         Macro
  415.         _LMGetKeyThresh      &dest=(sp)
  416.         move.w               $018E,&dest
  417.         EndM
  418.     ELSE
  419.         IMPORT_CFM_FUNCTION    LMGetKeyThresh
  420.     ENDIF
  421.  
  422. ;
  423. ; pascal void LMSetKeyThresh(SInt16 value)
  424. ;
  425.     IF ¬ GENERATINGCFM THEN
  426.         Macro
  427.         _LMSetKeyThresh      &src=(sp)+
  428.         move.w               &src,$018E
  429.         EndM
  430.     ELSE
  431.         IMPORT_CFM_FUNCTION    LMSetKeyThresh
  432.     ENDIF
  433.  
  434. ;
  435. ; pascal SInt16 LMGetKeyRepThresh(void)
  436. ;
  437.     IF ¬ GENERATINGCFM THEN
  438.         Macro
  439.         _LMGetKeyRepThresh   &dest=(sp)
  440.         move.w               $0190,&dest
  441.         EndM
  442.     ELSE
  443.         IMPORT_CFM_FUNCTION    LMGetKeyRepThresh
  444.     ENDIF
  445.  
  446. ;
  447. ; pascal void LMSetKeyRepThresh(SInt16 value)
  448. ;
  449.     IF ¬ GENERATINGCFM THEN
  450.         Macro
  451.         _LMSetKeyRepThresh   &src=(sp)+
  452.         move.w               &src,$0190
  453.         EndM
  454.     ELSE
  455.         IMPORT_CFM_FUNCTION    LMSetKeyRepThresh
  456.     ENDIF
  457.  
  458. ;
  459. ; pascal SInt16 LMGetUnitTableEntryCount(void)
  460. ;
  461.     IF ¬ GENERATINGCFM THEN
  462.         Macro
  463.         _LMGetUnitTableEntryCount&dest=(sp)
  464.         move.w               $01D2,&dest
  465.         EndM
  466.     ELSE
  467.         IMPORT_CFM_FUNCTION    LMGetUnitTableEntryCount
  468.     ENDIF
  469.  
  470. ;
  471. ; pascal void LMSetUnitTableEntryCount(SInt16 value)
  472. ;
  473.     IF ¬ GENERATINGCFM THEN
  474.         Macro
  475.         _LMSetUnitTableEntryCount&src=(sp)+
  476.         move.w               &src,$01D2
  477.         EndM
  478.     ELSE
  479.         IMPORT_CFM_FUNCTION    LMSetUnitTableEntryCount
  480.     ENDIF
  481.  
  482. ;
  483. ; pascal Ptr LMGetVIA(void)
  484. ;
  485.     IF ¬ GENERATINGCFM THEN
  486.         Macro
  487.         _LMGetVIA            &dest=(sp)
  488.         move.l               $01D4,&dest
  489.         EndM
  490.     ELSE
  491.         IMPORT_CFM_FUNCTION    LMGetVIA
  492.     ENDIF
  493.  
  494. ;
  495. ; pascal void LMSetVIA(Ptr value)
  496. ;
  497.     IF ¬ GENERATINGCFM THEN
  498.         Macro
  499.         _LMSetVIA            &src=(sp)+
  500.         move.l               &src,$01D4
  501.         EndM
  502.     ELSE
  503.         IMPORT_CFM_FUNCTION    LMSetVIA
  504.     ENDIF
  505.  
  506. ;
  507. ; pascal Ptr LMGetSCCRd(void)
  508. ;
  509.     IF ¬ GENERATINGCFM THEN
  510.         Macro
  511.         _LMGetSCCRd          &dest=(sp)
  512.         move.l               $01D8,&dest
  513.         EndM
  514.     ELSE
  515.         IMPORT_CFM_FUNCTION    LMGetSCCRd
  516.     ENDIF
  517.  
  518. ;
  519. ; pascal void LMSetSCCRd(Ptr value)
  520. ;
  521.     IF ¬ GENERATINGCFM THEN
  522.         Macro
  523.         _LMSetSCCRd          &src=(sp)+
  524.         move.l               &src,$01D8
  525.         EndM
  526.     ELSE
  527.         IMPORT_CFM_FUNCTION    LMSetSCCRd
  528.     ENDIF
  529.  
  530. ;
  531. ; pascal Ptr LMGetSCCWr(void)
  532. ;
  533.     IF ¬ GENERATINGCFM THEN
  534.         Macro
  535.         _LMGetSCCWr          &dest=(sp)
  536.         move.l               $01DC,&dest
  537.         EndM
  538.     ELSE
  539.         IMPORT_CFM_FUNCTION    LMGetSCCWr
  540.     ENDIF
  541.  
  542. ;
  543. ; pascal void LMSetSCCWr(Ptr value)
  544. ;
  545.     IF ¬ GENERATINGCFM THEN
  546.         Macro
  547.         _LMSetSCCWr          &src=(sp)+
  548.         move.l               &src,$01DC
  549.         EndM
  550.     ELSE
  551.         IMPORT_CFM_FUNCTION    LMSetSCCWr
  552.     ENDIF
  553.  
  554. ;
  555. ; pascal UInt8 LMGetSPValid(void)
  556. ;
  557.     IF ¬ GENERATINGCFM THEN
  558.         Macro
  559.         _LMGetSPValid        &dest=(sp)
  560.         move.b               $01F8,&dest
  561.         EndM
  562.     ELSE
  563.         IMPORT_CFM_FUNCTION    LMGetSPValid
  564.     ENDIF
  565.  
  566. ;
  567. ; pascal void LMSetSPValid(UInt8 value)
  568. ;
  569.     IF ¬ GENERATINGCFM THEN
  570.         Macro
  571.         _LMSetSPValid        &src=(sp)+
  572.         move.b               &src,$01F8
  573.         EndM
  574.     ELSE
  575.         IMPORT_CFM_FUNCTION    LMSetSPValid
  576.     ENDIF
  577.  
  578. ;
  579. ; pascal UInt8 LMGetSPATalkA(void)
  580. ;
  581.     IF ¬ GENERATINGCFM THEN
  582.         Macro
  583.         _LMGetSPATalkA       &dest=(sp)
  584.         move.b               $01F9,&dest
  585.         EndM
  586.     ELSE
  587.         IMPORT_CFM_FUNCTION    LMGetSPATalkA
  588.     ENDIF
  589.  
  590. ;
  591. ; pascal void LMSetSPATalkA(UInt8 value)
  592. ;
  593.     IF ¬ GENERATINGCFM THEN
  594.         Macro
  595.         _LMSetSPATalkA       &src=(sp)+
  596.         move.b               &src,$01F9
  597.         EndM
  598.     ELSE
  599.         IMPORT_CFM_FUNCTION    LMSetSPATalkA
  600.     ENDIF
  601.  
  602. ;
  603. ; pascal UInt8 LMGetSPATalkB(void)
  604. ;
  605.     IF ¬ GENERATINGCFM THEN
  606.         Macro
  607.         _LMGetSPATalkB       &dest=(sp)
  608.         move.b               $01FA,&dest
  609.         EndM
  610.     ELSE
  611.         IMPORT_CFM_FUNCTION    LMGetSPATalkB
  612.     ENDIF
  613.  
  614. ;
  615. ; pascal void LMSetSPATalkB(UInt8 value)
  616. ;
  617.     IF ¬ GENERATINGCFM THEN
  618.         Macro
  619.         _LMSetSPATalkB       &src=(sp)+
  620.         move.b               &src,$01FA
  621.         EndM
  622.     ELSE
  623.         IMPORT_CFM_FUNCTION    LMSetSPATalkB
  624.     ENDIF
  625.  
  626. ;
  627. ; pascal UInt8 LMGetSPConfig(void)
  628. ;
  629.     IF ¬ GENERATINGCFM THEN
  630.         Macro
  631.         _LMGetSPConfig       &dest=(sp)
  632.         move.b               $01FB,&dest
  633.         EndM
  634.     ELSE
  635.         IMPORT_CFM_FUNCTION    LMGetSPConfig
  636.     ENDIF
  637.  
  638. ;
  639. ; pascal void LMSetSPConfig(UInt8 value)
  640. ;
  641.     IF ¬ GENERATINGCFM THEN
  642.         Macro
  643.         _LMSetSPConfig       &src=(sp)+
  644.         move.b               &src,$01FB
  645.         EndM
  646.     ELSE
  647.         IMPORT_CFM_FUNCTION    LMSetSPConfig
  648.     ENDIF
  649.  
  650. ;
  651. ; pascal SInt16 LMGetSPPortA(void)
  652. ;
  653.     IF ¬ GENERATINGCFM THEN
  654.         Macro
  655.         _LMGetSPPortA        &dest=(sp)
  656.         move.w               $01FC,&dest
  657.         EndM
  658.     ELSE
  659.         IMPORT_CFM_FUNCTION    LMGetSPPortA
  660.     ENDIF
  661.  
  662. ;
  663. ; pascal void LMSetSPPortA(SInt16 value)
  664. ;
  665.     IF ¬ GENERATINGCFM THEN
  666.         Macro
  667.         _LMSetSPPortA        &src=(sp)+
  668.         move.w               &src,$01FC
  669.         EndM
  670.     ELSE
  671.         IMPORT_CFM_FUNCTION    LMSetSPPortA
  672.     ENDIF
  673.  
  674. ;
  675. ; pascal SInt16 LMGetSPPortB(void)
  676. ;
  677.     IF ¬ GENERATINGCFM THEN
  678.         Macro
  679.         _LMGetSPPortB        &dest=(sp)
  680.         move.w               $01FE,&dest
  681.         EndM
  682.     ELSE
  683.         IMPORT_CFM_FUNCTION    LMGetSPPortB
  684.     ENDIF
  685.  
  686. ;
  687. ; pascal void LMSetSPPortB(SInt16 value)
  688. ;
  689.     IF ¬ GENERATINGCFM THEN
  690.         Macro
  691.         _LMSetSPPortB        &src=(sp)+
  692.         move.w               &src,$01FE
  693.         EndM
  694.     ELSE
  695.         IMPORT_CFM_FUNCTION    LMSetSPPortB
  696.     ENDIF
  697.  
  698. ;
  699. ; pascal SInt32 LMGetSPAlarm(void)
  700. ;
  701.     IF ¬ GENERATINGCFM THEN
  702.         Macro
  703.         _LMGetSPAlarm        &dest=(sp)
  704.         move.l               $0200,&dest
  705.         EndM
  706.     ELSE
  707.         IMPORT_CFM_FUNCTION    LMGetSPAlarm
  708.     ENDIF
  709.  
  710. ;
  711. ; pascal void LMSetSPAlarm(SInt32 value)
  712. ;
  713.     IF ¬ GENERATINGCFM THEN
  714.         Macro
  715.         _LMSetSPAlarm        &src=(sp)+
  716.         move.l               &src,$0200
  717.         EndM
  718.     ELSE
  719.         IMPORT_CFM_FUNCTION    LMSetSPAlarm
  720.     ENDIF
  721.  
  722. ;
  723. ; pascal SInt16 LMGetSPFont(void)
  724. ;
  725.     IF ¬ GENERATINGCFM THEN
  726.         Macro
  727.         _LMGetSPFont         &dest=(sp)
  728.         move.w               $0204,&dest
  729.         EndM
  730.     ELSE
  731.         IMPORT_CFM_FUNCTION    LMGetSPFont
  732.     ENDIF
  733.  
  734. ;
  735. ; pascal void LMSetSPFont(SInt16 value)
  736. ;
  737.     IF ¬ GENERATINGCFM THEN
  738.         Macro
  739.         _LMSetSPFont         &src=(sp)+
  740.         move.w               &src,$0204
  741.         EndM
  742.     ELSE
  743.         IMPORT_CFM_FUNCTION    LMSetSPFont
  744.     ENDIF
  745.  
  746. ;
  747. ; pascal UInt8 LMGetSPKbd(void)
  748. ;
  749.     IF ¬ GENERATINGCFM THEN
  750.         Macro
  751.         _LMGetSPKbd          &dest=(sp)
  752.         move.b               $0206,&dest
  753.         EndM
  754.     ELSE
  755.         IMPORT_CFM_FUNCTION    LMGetSPKbd
  756.     ENDIF
  757.  
  758. ;
  759. ; pascal void LMSetSPKbd(UInt8 value)
  760. ;
  761.     IF ¬ GENERATINGCFM THEN
  762.         Macro
  763.         _LMSetSPKbd          &src=(sp)+
  764.         move.b               &src,$0206
  765.         EndM
  766.     ELSE
  767.         IMPORT_CFM_FUNCTION    LMSetSPKbd
  768.     ENDIF
  769.  
  770. ;
  771. ; pascal UInt8 LMGetSPPrint(void)
  772. ;
  773.     IF ¬ GENERATINGCFM THEN
  774.         Macro
  775.         _LMGetSPPrint        &dest=(sp)
  776.         move.b               $0207,&dest
  777.         EndM
  778.     ELSE
  779.         IMPORT_CFM_FUNCTION    LMGetSPPrint
  780.     ENDIF
  781.  
  782. ;
  783. ; pascal void LMSetSPPrint(UInt8 value)
  784. ;
  785.     IF ¬ GENERATINGCFM THEN
  786.         Macro
  787.         _LMSetSPPrint        &src=(sp)+
  788.         move.b               &src,$0207
  789.         EndM
  790.     ELSE
  791.         IMPORT_CFM_FUNCTION    LMSetSPPrint
  792.     ENDIF
  793.  
  794. ;
  795. ; pascal UInt8 LMGetSPVolCtl(void)
  796. ;
  797.     IF ¬ GENERATINGCFM THEN
  798.         Macro
  799.         _LMGetSPVolCtl       &dest=(sp)
  800.         move.b               $0208,&dest
  801.         EndM
  802.     ELSE
  803.         IMPORT_CFM_FUNCTION    LMGetSPVolCtl
  804.     ENDIF
  805.  
  806. ;
  807. ; pascal void LMSetSPVolCtl(UInt8 value)
  808. ;
  809.     IF ¬ GENERATINGCFM THEN
  810.         Macro
  811.         _LMSetSPVolCtl       &src=(sp)+
  812.         move.b               &src,$0208
  813.         EndM
  814.     ELSE
  815.         IMPORT_CFM_FUNCTION    LMSetSPVolCtl
  816.     ENDIF
  817.  
  818. ;
  819. ; pascal UInt8 LMGetSPClikCaret(void)
  820. ;
  821.     IF ¬ GENERATINGCFM THEN
  822.         Macro
  823.         _LMGetSPClikCaret    &dest=(sp)
  824.         move.b               $0209,&dest
  825.         EndM
  826.     ELSE
  827.         IMPORT_CFM_FUNCTION    LMGetSPClikCaret
  828.     ENDIF
  829.  
  830. ;
  831. ; pascal void LMSetSPClikCaret(UInt8 value)
  832. ;
  833.     IF ¬ GENERATINGCFM THEN
  834.         Macro
  835.         _LMSetSPClikCaret    &src=(sp)+
  836.         move.b               &src,$0209
  837.         EndM
  838.     ELSE
  839.         IMPORT_CFM_FUNCTION    LMSetSPClikCaret
  840.     ENDIF
  841.  
  842. ;
  843. ; pascal UInt8 LMGetSPMisc2(void)
  844. ;
  845.     IF ¬ GENERATINGCFM THEN
  846.         Macro
  847.         _LMGetSPMisc2        &dest=(sp)
  848.         move.b               $020B,&dest
  849.         EndM
  850.     ELSE
  851.         IMPORT_CFM_FUNCTION    LMGetSPMisc2
  852.     ENDIF
  853.  
  854. ;
  855. ; pascal void LMSetSPMisc2(UInt8 value)
  856. ;
  857.     IF ¬ GENERATINGCFM THEN
  858.         Macro
  859.         _LMSetSPMisc2        &src=(sp)+
  860.         move.b               &src,$020B
  861.         EndM
  862.     ELSE
  863.         IMPORT_CFM_FUNCTION    LMSetSPMisc2
  864.     ENDIF
  865.  
  866. ;
  867. ; pascal SInt32 LMGetTime(void)
  868. ;
  869.     IF ¬ GENERATINGCFM THEN
  870.         Macro
  871.         _LMGetTime           &dest=(sp)
  872.         move.l               $020C,&dest
  873.         EndM
  874.     ELSE
  875.         IMPORT_CFM_FUNCTION    LMGetTime
  876.     ENDIF
  877.  
  878. ;
  879. ; pascal void LMSetTime(SInt32 value)
  880. ;
  881.     IF ¬ GENERATINGCFM THEN
  882.         Macro
  883.         _LMSetTime           &src=(sp)+
  884.         move.l               &src,$020C
  885.         EndM
  886.     ELSE
  887.         IMPORT_CFM_FUNCTION    LMSetTime
  888.     ENDIF
  889.  
  890. ;
  891. ; pascal SInt16 LMGetBootDrive(void)
  892. ;
  893.     IF ¬ GENERATINGCFM THEN
  894.         Macro
  895.         _LMGetBootDrive      &dest=(sp)
  896.         move.w               $0210,&dest
  897.         EndM
  898.     ELSE
  899.         IMPORT_CFM_FUNCTION    LMGetBootDrive
  900.     ENDIF
  901.  
  902. ;
  903. ; pascal void LMSetBootDrive(SInt16 value)
  904. ;
  905.     IF ¬ GENERATINGCFM THEN
  906.         Macro
  907.         _LMSetBootDrive      &src=(sp)+
  908.         move.w               &src,$0210
  909.         EndM
  910.     ELSE
  911.         IMPORT_CFM_FUNCTION    LMSetBootDrive
  912.     ENDIF
  913.  
  914. ;
  915. ; pascal SInt16 LMGetSFSaveDisk(void)
  916. ;
  917.     IF ¬ GENERATINGCFM THEN
  918.         Macro
  919.         _LMGetSFSaveDisk     &dest=(sp)
  920.         move.w               $0214,&dest
  921.         EndM
  922.     ELSE
  923.         IMPORT_CFM_FUNCTION    LMGetSFSaveDisk
  924.     ENDIF
  925.  
  926. ;
  927. ; pascal void LMSetSFSaveDisk(SInt16 value)
  928. ;
  929.     IF ¬ GENERATINGCFM THEN
  930.         Macro
  931.         _LMSetSFSaveDisk     &src=(sp)+
  932.         move.w               &src,$0214
  933.         EndM
  934.     ELSE
  935.         IMPORT_CFM_FUNCTION    LMSetSFSaveDisk
  936.     ENDIF
  937.  
  938. ;
  939. ; pascal UInt8 LMGetKbdLast(void)
  940. ;
  941.     IF ¬ GENERATINGCFM THEN
  942.         Macro
  943.         _LMGetKbdLast        &dest=(sp)
  944.         move.b               $0218,&dest
  945.         EndM
  946.     ELSE
  947.         IMPORT_CFM_FUNCTION    LMGetKbdLast
  948.     ENDIF
  949.  
  950. ;
  951. ; pascal void LMSetKbdLast(UInt8 value)
  952. ;
  953.     IF ¬ GENERATINGCFM THEN
  954.         Macro
  955.         _LMSetKbdLast        &src=(sp)+
  956.         move.b               &src,$0218
  957.         EndM
  958.     ELSE
  959.         IMPORT_CFM_FUNCTION    LMSetKbdLast
  960.     ENDIF
  961.  
  962. ;
  963. ; pascal UInt8 LMGetKbdType(void)
  964. ;
  965.     IF ¬ GENERATINGCFM THEN
  966.         Macro
  967.         _LMGetKbdType        &dest=(sp)
  968.         move.b               $021E,&dest
  969.         EndM
  970.     ELSE
  971.         IMPORT_CFM_FUNCTION    LMGetKbdType
  972.     ENDIF
  973.  
  974. ;
  975. ; pascal void LMSetKbdType(UInt8 value)
  976. ;
  977.     IF ¬ GENERATINGCFM THEN
  978.         Macro
  979.         _LMSetKbdType        &src=(sp)+
  980.         move.b               &src,$021E
  981.         EndM
  982.     ELSE
  983.         IMPORT_CFM_FUNCTION    LMSetKbdType
  984.     ENDIF
  985.  
  986. ;
  987. ; pascal SInt16 LMGetMemErr(void)
  988. ;
  989.     IF ¬ GENERATINGCFM THEN
  990.         Macro
  991.         _LMGetMemErr         &dest=(sp)
  992.         move.w               $0220,&dest
  993.         EndM
  994.     ELSE
  995.         IMPORT_CFM_FUNCTION    LMGetMemErr
  996.     ENDIF
  997.  
  998. ;
  999. ; pascal void LMSetMemErr(SInt16 value)
  1000. ;
  1001.     IF ¬ GENERATINGCFM THEN
  1002.         Macro
  1003.         _LMSetMemErr         &src=(sp)+
  1004.         move.w               &src,$0220
  1005.         EndM
  1006.     ELSE
  1007.         IMPORT_CFM_FUNCTION    LMSetMemErr
  1008.     ENDIF
  1009.  
  1010. ;
  1011. ; pascal UInt8 LMGetSdVolume(void)
  1012. ;
  1013.     IF ¬ GENERATINGCFM THEN
  1014.         Macro
  1015.         _LMGetSdVolume       &dest=(sp)
  1016.         move.b               $0260,&dest
  1017.         EndM
  1018.     ELSE
  1019.         IMPORT_CFM_FUNCTION    LMGetSdVolume
  1020.     ENDIF
  1021.  
  1022. ;
  1023. ; pascal void LMSetSdVolume(UInt8 value)
  1024. ;
  1025.     IF ¬ GENERATINGCFM THEN
  1026.         Macro
  1027.         _LMSetSdVolume       &src=(sp)+
  1028.         move.b               &src,$0260
  1029.         EndM
  1030.     ELSE
  1031.         IMPORT_CFM_FUNCTION    LMSetSdVolume
  1032.     ENDIF
  1033.  
  1034. ;
  1035. ; pascal Ptr LMGetSoundPtr(void)
  1036. ;
  1037.     IF ¬ GENERATINGCFM THEN
  1038.         Macro
  1039.         _LMGetSoundPtr       &dest=(sp)
  1040.         move.l               $0262,&dest
  1041.         EndM
  1042.     ELSE
  1043.         IMPORT_CFM_FUNCTION    LMGetSoundPtr
  1044.     ENDIF
  1045.  
  1046. ;
  1047. ; pascal void LMSetSoundPtr(Ptr value)
  1048. ;
  1049.     IF ¬ GENERATINGCFM THEN
  1050.         Macro
  1051.         _LMSetSoundPtr       &src=(sp)+
  1052.         move.l               &src,$0262
  1053.         EndM
  1054.     ELSE
  1055.         IMPORT_CFM_FUNCTION    LMSetSoundPtr
  1056.     ENDIF
  1057.  
  1058. ;
  1059. ; pascal Ptr LMGetSoundBase(void)
  1060. ;
  1061.     IF ¬ GENERATINGCFM THEN
  1062.         Macro
  1063.         _LMGetSoundBase      &dest=(sp)
  1064.         move.l               $0266,&dest
  1065.         EndM
  1066.     ELSE
  1067.         IMPORT_CFM_FUNCTION    LMGetSoundBase
  1068.     ENDIF
  1069.  
  1070. ;
  1071. ; pascal void LMSetSoundBase(Ptr value)
  1072. ;
  1073.     IF ¬ GENERATINGCFM THEN
  1074.         Macro
  1075.         _LMSetSoundBase      &src=(sp)+
  1076.         move.l               &src,$0266
  1077.         EndM
  1078.     ELSE
  1079.         IMPORT_CFM_FUNCTION    LMSetSoundBase
  1080.     ENDIF
  1081.  
  1082. ;
  1083. ; pascal UInt8 LMGetSoundLevel(void)
  1084. ;
  1085.     IF ¬ GENERATINGCFM THEN
  1086.         Macro
  1087.         _LMGetSoundLevel     &dest=(sp)
  1088.         move.b               $027F,&dest
  1089.         EndM
  1090.     ELSE
  1091.         IMPORT_CFM_FUNCTION    LMGetSoundLevel
  1092.     ENDIF
  1093.  
  1094. ;
  1095. ; pascal void LMSetSoundLevel(UInt8 value)
  1096. ;
  1097.     IF ¬ GENERATINGCFM THEN
  1098.         Macro
  1099.         _LMSetSoundLevel     &src=(sp)+
  1100.         move.b               &src,$027F
  1101.         EndM
  1102.     ELSE
  1103.         IMPORT_CFM_FUNCTION    LMSetSoundLevel
  1104.     ENDIF
  1105.  
  1106. ;
  1107. ; pascal SInt16 LMGetCurPitch(void)
  1108. ;
  1109.     IF ¬ GENERATINGCFM THEN
  1110.         Macro
  1111.         _LMGetCurPitch       &dest=(sp)
  1112.         move.w               $0280,&dest
  1113.         EndM
  1114.     ELSE
  1115.         IMPORT_CFM_FUNCTION    LMGetCurPitch
  1116.     ENDIF
  1117.  
  1118. ;
  1119. ; pascal void LMSetCurPitch(SInt16 value)
  1120. ;
  1121.     IF ¬ GENERATINGCFM THEN
  1122.         Macro
  1123.         _LMSetCurPitch       &src=(sp)+
  1124.         move.w               &src,$0280
  1125.         EndM
  1126.     ELSE
  1127.         IMPORT_CFM_FUNCTION    LMSetCurPitch
  1128.     ENDIF
  1129.  
  1130. ;
  1131. ; pascal SInt16 LMGetROM85(void)
  1132. ;
  1133.     IF ¬ GENERATINGCFM THEN
  1134.         Macro
  1135.         _LMGetROM85          &dest=(sp)
  1136.         move.w               $028E,&dest
  1137.         EndM
  1138.     ELSE
  1139.         IMPORT_CFM_FUNCTION    LMGetROM85
  1140.     ENDIF
  1141.  
  1142. ;
  1143. ; pascal void LMSetROM85(SInt16 value)
  1144. ;
  1145.     IF ¬ GENERATINGCFM THEN
  1146.         Macro
  1147.         _LMSetROM85          &src=(sp)+
  1148.         move.w               &src,$028E
  1149.         EndM
  1150.     ELSE
  1151.         IMPORT_CFM_FUNCTION    LMSetROM85
  1152.     ENDIF
  1153.  
  1154. ;
  1155. ; pascal UInt8 LMGetPortBUse(void)
  1156. ;
  1157.     IF ¬ GENERATINGCFM THEN
  1158.         Macro
  1159.         _LMGetPortBUse       &dest=(sp)
  1160.         move.b               $0291,&dest
  1161.         EndM
  1162.     ELSE
  1163.         IMPORT_CFM_FUNCTION    LMGetPortBUse
  1164.     ENDIF
  1165.  
  1166. ;
  1167. ; pascal void LMSetPortBUse(UInt8 value)
  1168. ;
  1169.     IF ¬ GENERATINGCFM THEN
  1170.         Macro
  1171.         _LMSetPortBUse       &src=(sp)+
  1172.         move.b               &src,$0291
  1173.         EndM
  1174.     ELSE
  1175.         IMPORT_CFM_FUNCTION    LMSetPortBUse
  1176.     ENDIF
  1177.  
  1178. ;
  1179. ; pascal GNEFilterUPP LMGetGNEFilter(void)
  1180. ;
  1181.     IF ¬ GENERATINGCFM THEN
  1182.         Macro
  1183.         _LMGetGNEFilter      &dest=(sp)
  1184.         move.l               $029A,&dest
  1185.         EndM
  1186.     ELSE
  1187.         IMPORT_CFM_FUNCTION    LMGetGNEFilter
  1188.     ENDIF
  1189.  
  1190. ;
  1191. ; pascal void LMSetGNEFilter(GNEFilterUPP value)
  1192. ;
  1193.     IF ¬ GENERATINGCFM THEN
  1194.         Macro
  1195.         _LMSetGNEFilter      &src=(sp)+
  1196.         move.l               &src,$029A
  1197.         EndM
  1198.     ELSE
  1199.         IMPORT_CFM_FUNCTION    LMSetGNEFilter
  1200.     ENDIF
  1201.  
  1202. ;
  1203. ; pascal THz LMGetSysZone(void)
  1204. ;
  1205.     IF ¬ GENERATINGCFM THEN
  1206.         Macro
  1207.         _LMGetSysZone        &dest=(sp)
  1208.         move.l               $02A6,&dest
  1209.         EndM
  1210.     ELSE
  1211.         IMPORT_CFM_FUNCTION    LMGetSysZone
  1212.     ENDIF
  1213.  
  1214. ;
  1215. ; pascal void LMSetSysZone(THz value)
  1216. ;
  1217.     IF ¬ GENERATINGCFM THEN
  1218.         Macro
  1219.         _LMSetSysZone        &src=(sp)+
  1220.         move.l               &src,$02A6
  1221.         EndM
  1222.     ELSE
  1223.         IMPORT_CFM_FUNCTION    LMSetSysZone
  1224.     ENDIF
  1225.  
  1226. ;
  1227. ; pascal THz LMGetApplZone(void)
  1228. ;
  1229.     IF ¬ GENERATINGCFM THEN
  1230.         Macro
  1231.         _LMGetApplZone       &dest=(sp)
  1232.         move.l               $02AA,&dest
  1233.         EndM
  1234.     ELSE
  1235.         IMPORT_CFM_FUNCTION    LMGetApplZone
  1236.     ENDIF
  1237.  
  1238. ;
  1239. ; pascal void LMSetApplZone(THz value)
  1240. ;
  1241.     IF ¬ GENERATINGCFM THEN
  1242.         Macro
  1243.         _LMSetApplZone       &src=(sp)+
  1244.         move.l               &src,$02AA
  1245.         EndM
  1246.     ELSE
  1247.         IMPORT_CFM_FUNCTION    LMSetApplZone
  1248.     ENDIF
  1249.  
  1250. ;
  1251. ; pascal Ptr LMGetROMBase(void)
  1252. ;
  1253.     IF ¬ GENERATINGCFM THEN
  1254.         Macro
  1255.         _LMGetROMBase        &dest=(sp)
  1256.         move.l               $02AE,&dest
  1257.         EndM
  1258.     ELSE
  1259.         IMPORT_CFM_FUNCTION    LMGetROMBase
  1260.     ENDIF
  1261.  
  1262. ;
  1263. ; pascal void LMSetROMBase(Ptr value)
  1264. ;
  1265.     IF ¬ GENERATINGCFM THEN
  1266.         Macro
  1267.         _LMSetROMBase        &src=(sp)+
  1268.         move.l               &src,$02AE
  1269.         EndM
  1270.     ELSE
  1271.         IMPORT_CFM_FUNCTION    LMSetROMBase
  1272.     ENDIF
  1273.  
  1274. ;
  1275. ; pascal Ptr LMGetRAMBase(void)
  1276. ;
  1277.     IF ¬ GENERATINGCFM THEN
  1278.         Macro
  1279.         _LMGetRAMBase        &dest=(sp)
  1280.         move.l               $02B2,&dest
  1281.         EndM
  1282.     ELSE
  1283.         IMPORT_CFM_FUNCTION    LMGetRAMBase
  1284.     ENDIF
  1285.  
  1286. ;
  1287. ; pascal void LMSetRAMBase(Ptr value)
  1288. ;
  1289.     IF ¬ GENERATINGCFM THEN
  1290.         Macro
  1291.         _LMSetRAMBase        &src=(sp)+
  1292.         move.l               &src,$02B2
  1293.         EndM
  1294.     ELSE
  1295.         IMPORT_CFM_FUNCTION    LMSetRAMBase
  1296.     ENDIF
  1297.  
  1298. ;
  1299. ; pascal Ptr LMGetDSAlertTab(void)
  1300. ;
  1301.     IF ¬ GENERATINGCFM THEN
  1302.         Macro
  1303.         _LMGetDSAlertTab     &dest=(sp)
  1304.         move.l               $02BA,&dest
  1305.         EndM
  1306.     ELSE
  1307.         IMPORT_CFM_FUNCTION    LMGetDSAlertTab
  1308.     ENDIF
  1309.  
  1310. ;
  1311. ; pascal void LMSetDSAlertTab(Ptr value)
  1312. ;
  1313.     IF ¬ GENERATINGCFM THEN
  1314.         Macro
  1315.         _LMSetDSAlertTab     &src=(sp)+
  1316.         move.l               &src,$02BA
  1317.         EndM
  1318.     ELSE
  1319.         IMPORT_CFM_FUNCTION    LMSetDSAlertTab
  1320.     ENDIF
  1321.  
  1322. ;
  1323. ; pascal UInt32 LMGetDoubleTime(void)
  1324. ;
  1325.     IF ¬ GENERATINGCFM THEN
  1326.         Macro
  1327.         _LMGetDoubleTime     &dest=(sp)
  1328.         move.l               $02F0,&dest
  1329.         EndM
  1330.     ELSE
  1331.         IMPORT_CFM_FUNCTION    LMGetDoubleTime
  1332.     ENDIF
  1333.  
  1334. ;
  1335. ; pascal void LMSetDoubleTime(UInt32 value)
  1336. ;
  1337.     IF ¬ GENERATINGCFM THEN
  1338.         Macro
  1339.         _LMSetDoubleTime     &src=(sp)+
  1340.         move.l               &src,$02F0
  1341.         EndM
  1342.     ELSE
  1343.         IMPORT_CFM_FUNCTION    LMSetDoubleTime
  1344.     ENDIF
  1345.  
  1346. ;
  1347. ; pascal UInt32 LMGetCaretTime(void)
  1348. ;
  1349.     IF ¬ GENERATINGCFM THEN
  1350.         Macro
  1351.         _LMGetCaretTime      &dest=(sp)
  1352.         move.l               $02F4,&dest
  1353.         EndM
  1354.     ELSE
  1355.         IMPORT_CFM_FUNCTION    LMGetCaretTime
  1356.     ENDIF
  1357.  
  1358. ;
  1359. ; pascal void LMSetCaretTime(UInt32 value)
  1360. ;
  1361.     IF ¬ GENERATINGCFM THEN
  1362.         Macro
  1363.         _LMSetCaretTime      &src=(sp)+
  1364.         move.l               &src,$02F4
  1365.         EndM
  1366.     ELSE
  1367.         IMPORT_CFM_FUNCTION    LMSetCaretTime
  1368.     ENDIF
  1369.  
  1370. ;
  1371. ; pascal UInt8 LMGetScrDmpEnb(void)
  1372. ;
  1373.     IF ¬ GENERATINGCFM THEN
  1374.         Macro
  1375.         _LMGetScrDmpEnb      &dest=(sp)
  1376.         move.b               $02F8,&dest
  1377.         EndM
  1378.     ELSE
  1379.         IMPORT_CFM_FUNCTION    LMGetScrDmpEnb
  1380.     ENDIF
  1381.  
  1382. ;
  1383. ; pascal void LMSetScrDmpEnb(UInt8 value)
  1384. ;
  1385.     IF ¬ GENERATINGCFM THEN
  1386.         Macro
  1387.         _LMSetScrDmpEnb      &src=(sp)+
  1388.         move.b               &src,$02F8
  1389.         EndM
  1390.     ELSE
  1391.         IMPORT_CFM_FUNCTION    LMSetScrDmpEnb
  1392.     ENDIF
  1393.  
  1394. ;
  1395. ; pascal SInt32 LMGetBufTgFNum(void)
  1396. ;
  1397.     IF ¬ GENERATINGCFM THEN
  1398.         Macro
  1399.         _LMGetBufTgFNum      &dest=(sp)
  1400.         move.l               $02FC,&dest
  1401.         EndM
  1402.     ELSE
  1403.         IMPORT_CFM_FUNCTION    LMGetBufTgFNum
  1404.     ENDIF
  1405.  
  1406. ;
  1407. ; pascal void LMSetBufTgFNum(SInt32 value)
  1408. ;
  1409.     IF ¬ GENERATINGCFM THEN
  1410.         Macro
  1411.         _LMSetBufTgFNum      &src=(sp)+
  1412.         move.l               &src,$02FC
  1413.         EndM
  1414.     ELSE
  1415.         IMPORT_CFM_FUNCTION    LMSetBufTgFNum
  1416.     ENDIF
  1417.  
  1418. ;
  1419. ; pascal SInt16 LMGetBufTgFFlg(void)
  1420. ;
  1421.     IF ¬ GENERATINGCFM THEN
  1422.         Macro
  1423.         _LMGetBufTgFFlg      &dest=(sp)
  1424.         move.w               $0300,&dest
  1425.         EndM
  1426.     ELSE
  1427.         IMPORT_CFM_FUNCTION    LMGetBufTgFFlg
  1428.     ENDIF
  1429.  
  1430. ;
  1431. ; pascal void LMSetBufTgFFlg(SInt16 value)
  1432. ;
  1433.     IF ¬ GENERATINGCFM THEN
  1434.         Macro
  1435.         _LMSetBufTgFFlg      &src=(sp)+
  1436.         move.w               &src,$0300
  1437.         EndM
  1438.     ELSE
  1439.         IMPORT_CFM_FUNCTION    LMSetBufTgFFlg
  1440.     ENDIF
  1441.  
  1442. ;
  1443. ; pascal SInt16 LMGetBufTgFBkNum(void)
  1444. ;
  1445.     IF ¬ GENERATINGCFM THEN
  1446.         Macro
  1447.         _LMGetBufTgFBkNum    &dest=(sp)
  1448.         move.w               $0302,&dest
  1449.         EndM
  1450.     ELSE
  1451.         IMPORT_CFM_FUNCTION    LMGetBufTgFBkNum
  1452.     ENDIF
  1453.  
  1454. ;
  1455. ; pascal void LMSetBufTgFBkNum(SInt16 value)
  1456. ;
  1457.     IF ¬ GENERATINGCFM THEN
  1458.         Macro
  1459.         _LMSetBufTgFBkNum    &src=(sp)+
  1460.         move.w               &src,$0302
  1461.         EndM
  1462.     ELSE
  1463.         IMPORT_CFM_FUNCTION    LMSetBufTgFBkNum
  1464.     ENDIF
  1465.  
  1466. ;
  1467. ; pascal SInt32 LMGetBufTgDate(void)
  1468. ;
  1469.     IF ¬ GENERATINGCFM THEN
  1470.         Macro
  1471.         _LMGetBufTgDate      &dest=(sp)
  1472.         move.l               $0304,&dest
  1473.         EndM
  1474.     ELSE
  1475.         IMPORT_CFM_FUNCTION    LMGetBufTgDate
  1476.     ENDIF
  1477.  
  1478. ;
  1479. ; pascal void LMSetBufTgDate(SInt32 value)
  1480. ;
  1481.     IF ¬ GENERATINGCFM THEN
  1482.         Macro
  1483.         _LMSetBufTgDate      &src=(sp)+
  1484.         move.l               &src,$0304
  1485.         EndM
  1486.     ELSE
  1487.         IMPORT_CFM_FUNCTION    LMSetBufTgDate
  1488.     ENDIF
  1489.  
  1490. ;
  1491. ; pascal SInt32 LMGetLo3Bytes(void)
  1492. ;
  1493.     IF ¬ GENERATINGCFM THEN
  1494.         Macro
  1495.         _LMGetLo3Bytes       &dest=(sp)
  1496.         move.l               $031A,&dest
  1497.         EndM
  1498.     ELSE
  1499.         IMPORT_CFM_FUNCTION    LMGetLo3Bytes
  1500.     ENDIF
  1501.  
  1502. ;
  1503. ; pascal void LMSetLo3Bytes(SInt32 value)
  1504. ;
  1505.     IF ¬ GENERATINGCFM THEN
  1506.         Macro
  1507.         _LMSetLo3Bytes       &src=(sp)+
  1508.         move.l               &src,$031A
  1509.         EndM
  1510.     ELSE
  1511.         IMPORT_CFM_FUNCTION    LMSetLo3Bytes
  1512.     ENDIF
  1513.  
  1514. ;
  1515. ; pascal SInt32 LMGetMinStack(void)
  1516. ;
  1517.     IF ¬ GENERATINGCFM THEN
  1518.         Macro
  1519.         _LMGetMinStack       &dest=(sp)
  1520.         move.l               $031E,&dest
  1521.         EndM
  1522.     ELSE
  1523.         IMPORT_CFM_FUNCTION    LMGetMinStack
  1524.     ENDIF
  1525.  
  1526. ;
  1527. ; pascal void LMSetMinStack(SInt32 value)
  1528. ;
  1529.     IF ¬ GENERATINGCFM THEN
  1530.         Macro
  1531.         _LMSetMinStack       &src=(sp)+
  1532.         move.l               &src,$031E
  1533.         EndM
  1534.     ELSE
  1535.         IMPORT_CFM_FUNCTION    LMSetMinStack
  1536.     ENDIF
  1537.  
  1538. ;
  1539. ; pascal SInt32 LMGetDefltStack(void)
  1540. ;
  1541.     IF ¬ GENERATINGCFM THEN
  1542.         Macro
  1543.         _LMGetDefltStack     &dest=(sp)
  1544.         move.l               $0322,&dest
  1545.         EndM
  1546.     ELSE
  1547.         IMPORT_CFM_FUNCTION    LMGetDefltStack
  1548.     ENDIF
  1549.  
  1550. ;
  1551. ; pascal void LMSetDefltStack(SInt32 value)
  1552. ;
  1553.     IF ¬ GENERATINGCFM THEN
  1554.         Macro
  1555.         _LMSetDefltStack     &src=(sp)+
  1556.         move.l               &src,$0322
  1557.         EndM
  1558.     ELSE
  1559.         IMPORT_CFM_FUNCTION    LMSetDefltStack
  1560.     ENDIF
  1561.  
  1562. ;
  1563. ; pascal Handle LMGetGZRootHnd(void)
  1564. ;
  1565.     IF ¬ GENERATINGCFM THEN
  1566.         Macro
  1567.         _LMGetGZRootHnd      &dest=(sp)
  1568.         move.l               $0328,&dest
  1569.         EndM
  1570.     ELSE
  1571.         IMPORT_CFM_FUNCTION    LMGetGZRootHnd
  1572.     ENDIF
  1573.  
  1574. ;
  1575. ; pascal void LMSetGZRootHnd(Handle value)
  1576. ;
  1577.     IF ¬ GENERATINGCFM THEN
  1578.         Macro
  1579.         _LMSetGZRootHnd      &src=(sp)+
  1580.         move.l               &src,$0328
  1581.         EndM
  1582.     ELSE
  1583.         IMPORT_CFM_FUNCTION    LMSetGZRootHnd
  1584.     ENDIF
  1585.  
  1586. ;
  1587. ; pascal Handle LMGetGZMoveHnd(void)
  1588. ;
  1589.     IF ¬ GENERATINGCFM THEN
  1590.         Macro
  1591.         _LMGetGZMoveHnd      &dest=(sp)
  1592.         move.l               $0330,&dest
  1593.         EndM
  1594.     ELSE
  1595.         IMPORT_CFM_FUNCTION    LMGetGZMoveHnd
  1596.     ENDIF
  1597.  
  1598. ;
  1599. ; pascal void LMSetGZMoveHnd(Handle value)
  1600. ;
  1601.     IF ¬ GENERATINGCFM THEN
  1602.         Macro
  1603.         _LMSetGZMoveHnd      &src=(sp)+
  1604.         move.l               &src,$0330
  1605.         EndM
  1606.     ELSE
  1607.         IMPORT_CFM_FUNCTION    LMSetGZMoveHnd
  1608.     ENDIF
  1609.  
  1610. ;
  1611. ; pascal Ptr LMGetFCBSPtr(void)
  1612. ;
  1613.     IF ¬ GENERATINGCFM THEN
  1614.         Macro
  1615.         _LMGetFCBSPtr        &dest=(sp)
  1616.         move.l               $034E,&dest
  1617.         EndM
  1618.     ELSE
  1619.         IMPORT_CFM_FUNCTION    LMGetFCBSPtr
  1620.     ENDIF
  1621.  
  1622. ;
  1623. ; pascal void LMSetFCBSPtr(Ptr value)
  1624. ;
  1625.     IF ¬ GENERATINGCFM THEN
  1626.         Macro
  1627.         _LMSetFCBSPtr        &src=(sp)+
  1628.         move.l               &src,$034E
  1629.         EndM
  1630.     ELSE
  1631.         IMPORT_CFM_FUNCTION    LMSetFCBSPtr
  1632.     ENDIF
  1633.  
  1634. ;
  1635. ; pascal Ptr LMGetDefVCBPtr(void)
  1636. ;
  1637.     IF ¬ GENERATINGCFM THEN
  1638.         Macro
  1639.         _LMGetDefVCBPtr      &dest=(sp)
  1640.         move.l               $0352,&dest
  1641.         EndM
  1642.     ELSE
  1643.         IMPORT_CFM_FUNCTION    LMGetDefVCBPtr
  1644.     ENDIF
  1645.  
  1646. ;
  1647. ; pascal void LMSetDefVCBPtr(Ptr value)
  1648. ;
  1649.     IF ¬ GENERATINGCFM THEN
  1650.         Macro
  1651.         _LMSetDefVCBPtr      &src=(sp)+
  1652.         move.l               &src,$0352
  1653.         EndM
  1654.     ELSE
  1655.         IMPORT_CFM_FUNCTION    LMSetDefVCBPtr
  1656.     ENDIF
  1657.  
  1658. ;
  1659. ; pascal SInt32 LMGetCurDirStore(void)
  1660. ;
  1661.     IF ¬ GENERATINGCFM THEN
  1662.         Macro
  1663.         _LMGetCurDirStore    &dest=(sp)
  1664.         move.l               $0398,&dest
  1665.         EndM
  1666.     ELSE
  1667.         IMPORT_CFM_FUNCTION    LMGetCurDirStore
  1668.     ENDIF
  1669.  
  1670. ;
  1671. ; pascal void LMSetCurDirStore(SInt32 value)
  1672. ;
  1673.     IF ¬ GENERATINGCFM THEN
  1674.         Macro
  1675.         _LMSetCurDirStore    &src=(sp)+
  1676.         move.l               &src,$0398
  1677.         EndM
  1678.     ELSE
  1679.         IMPORT_CFM_FUNCTION    LMSetCurDirStore
  1680.     ENDIF
  1681.  
  1682. ;
  1683. ; pascal UniversalProcPtr LMGetToExtFS(void)
  1684. ;
  1685.     IF ¬ GENERATINGCFM THEN
  1686.         Macro
  1687.         _LMGetToExtFS        &dest=(sp)
  1688.         move.l               $03F2,&dest
  1689.         EndM
  1690.     ELSE
  1691.         IMPORT_CFM_FUNCTION    LMGetToExtFS
  1692.     ENDIF
  1693.  
  1694. ;
  1695. ; pascal void LMSetToExtFS(UniversalProcPtr value)
  1696. ;
  1697.     IF ¬ GENERATINGCFM THEN
  1698.         Macro
  1699.         _LMSetToExtFS        &src=(sp)+
  1700.         move.l               &src,$03F2
  1701.         EndM
  1702.     ELSE
  1703.         IMPORT_CFM_FUNCTION    LMSetToExtFS
  1704.     ENDIF
  1705.  
  1706. ;
  1707. ; pascal SInt16 LMGetFSFCBLen(void)
  1708. ;
  1709.     IF ¬ GENERATINGCFM THEN
  1710.         Macro
  1711.         _LMGetFSFCBLen       &dest=(sp)
  1712.         move.w               $03F6,&dest
  1713.         EndM
  1714.     ELSE
  1715.         IMPORT_CFM_FUNCTION    LMGetFSFCBLen
  1716.     ENDIF
  1717.  
  1718. ;
  1719. ; pascal void LMSetFSFCBLen(SInt16 value)
  1720. ;
  1721.     IF ¬ GENERATINGCFM THEN
  1722.         Macro
  1723.         _LMSetFSFCBLen       &src=(sp)+
  1724.         move.w               &src,$03F6
  1725.         EndM
  1726.     ELSE
  1727.         IMPORT_CFM_FUNCTION    LMSetFSFCBLen
  1728.     ENDIF
  1729.  
  1730. ;
  1731. ; pascal Ptr LMGetScrnBase(void)
  1732. ;
  1733.     IF ¬ GENERATINGCFM THEN
  1734.         Macro
  1735.         _LMGetScrnBase       &dest=(sp)
  1736.         move.l               $0824,&dest
  1737.         EndM
  1738.     ELSE
  1739.         IMPORT_CFM_FUNCTION    LMGetScrnBase
  1740.     ENDIF
  1741.  
  1742. ;
  1743. ; pascal void LMSetScrnBase(Ptr value)
  1744. ;
  1745.     IF ¬ GENERATINGCFM THEN
  1746.         Macro
  1747.         _LMSetScrnBase       &src=(sp)+
  1748.         move.l               &src,$0824
  1749.         EndM
  1750.     ELSE
  1751.         IMPORT_CFM_FUNCTION    LMSetScrnBase
  1752.     ENDIF
  1753.  
  1754. ;
  1755. ; pascal GDHandle LMGetMainDevice(void)
  1756. ;
  1757.     IF ¬ GENERATINGCFM THEN
  1758.         Macro
  1759.         _LMGetMainDevice     &dest=(sp)
  1760.         move.l               $08A4,&dest
  1761.         EndM
  1762.     ELSE
  1763.         IMPORT_CFM_FUNCTION    LMGetMainDevice
  1764.     ENDIF
  1765.  
  1766. ;
  1767. ; pascal void LMSetMainDevice(GDHandle value)
  1768. ;
  1769.     IF ¬ GENERATINGCFM THEN
  1770.         Macro
  1771.         _LMSetMainDevice     &src=(sp)+
  1772.         move.l               &src,$08A4
  1773.         EndM
  1774.     ELSE
  1775.         IMPORT_CFM_FUNCTION    LMSetMainDevice
  1776.     ENDIF
  1777.  
  1778. ;
  1779. ; pascal GDHandle LMGetDeviceList(void)
  1780. ;
  1781.     IF ¬ GENERATINGCFM THEN
  1782.         Macro
  1783.         _LMGetDeviceList     &dest=(sp)
  1784.         move.l               $08A8,&dest
  1785.         EndM
  1786.     ELSE
  1787.         IMPORT_CFM_FUNCTION    LMGetDeviceList
  1788.     ENDIF
  1789.  
  1790. ;
  1791. ; pascal void LMSetDeviceList(GDHandle value)
  1792. ;
  1793.     IF ¬ GENERATINGCFM THEN
  1794.         Macro
  1795.         _LMSetDeviceList     &src=(sp)+
  1796.         move.l               &src,$08A8
  1797.         EndM
  1798.     ELSE
  1799.         IMPORT_CFM_FUNCTION    LMSetDeviceList
  1800.     ENDIF
  1801.  
  1802. ;
  1803. ; pascal Handle LMGetQDColors(void)
  1804. ;
  1805.     IF ¬ GENERATINGCFM THEN
  1806.         Macro
  1807.         _LMGetQDColors       &dest=(sp)
  1808.         move.l               $08B0,&dest
  1809.         EndM
  1810.     ELSE
  1811.         IMPORT_CFM_FUNCTION    LMGetQDColors
  1812.     ENDIF
  1813.  
  1814. ;
  1815. ; pascal void LMSetQDColors(Handle value)
  1816. ;
  1817.     IF ¬ GENERATINGCFM THEN
  1818.         Macro
  1819.         _LMSetQDColors       &src=(sp)+
  1820.         move.l               &src,$08B0
  1821.         EndM
  1822.     ELSE
  1823.         IMPORT_CFM_FUNCTION    LMSetQDColors
  1824.     ENDIF
  1825.  
  1826. ;
  1827. ; pascal UInt8 LMGetCrsrBusy(void)
  1828. ;
  1829.     IF ¬ GENERATINGCFM THEN
  1830.         Macro
  1831.         _LMGetCrsrBusy       &dest=(sp)
  1832.         move.b               $08CD,&dest
  1833.         EndM
  1834.     ELSE
  1835.         IMPORT_CFM_FUNCTION    LMGetCrsrBusy
  1836.     ENDIF
  1837.  
  1838. ;
  1839. ; pascal void LMSetCrsrBusy(UInt8 value)
  1840. ;
  1841.     IF ¬ GENERATINGCFM THEN
  1842.         Macro
  1843.         _LMSetCrsrBusy       &src=(sp)+
  1844.         move.b               &src,$08CD
  1845.         EndM
  1846.     ELSE
  1847.         IMPORT_CFM_FUNCTION    LMSetCrsrBusy
  1848.     ENDIF
  1849.  
  1850. ;
  1851. ; pascal Handle LMGetWidthListHand(void)
  1852. ;
  1853.     IF ¬ GENERATINGCFM THEN
  1854.         Macro
  1855.         _LMGetWidthListHand  &dest=(sp)
  1856.         move.l               $08E4,&dest
  1857.         EndM
  1858.     ELSE
  1859.         IMPORT_CFM_FUNCTION    LMGetWidthListHand
  1860.     ENDIF
  1861.  
  1862. ;
  1863. ; pascal void LMSetWidthListHand(Handle value)
  1864. ;
  1865.     IF ¬ GENERATINGCFM THEN
  1866.         Macro
  1867.         _LMSetWidthListHand  &src=(sp)+
  1868.         move.l               &src,$08E4
  1869.         EndM
  1870.     ELSE
  1871.         IMPORT_CFM_FUNCTION    LMSetWidthListHand
  1872.     ENDIF
  1873.  
  1874. ;
  1875. ; pascal SInt16 LMGetJournalRef(void)
  1876. ;
  1877.     IF ¬ GENERATINGCFM THEN
  1878.         Macro
  1879.         _LMGetJournalRef     &dest=(sp)
  1880.         move.w               $08E8,&dest
  1881.         EndM
  1882.     ELSE
  1883.         IMPORT_CFM_FUNCTION    LMGetJournalRef
  1884.     ENDIF
  1885.  
  1886. ;
  1887. ; pascal void LMSetJournalRef(SInt16 value)
  1888. ;
  1889.     IF ¬ GENERATINGCFM THEN
  1890.         Macro
  1891.         _LMSetJournalRef     &src=(sp)+
  1892.         move.w               &src,$08E8
  1893.         EndM
  1894.     ELSE
  1895.         IMPORT_CFM_FUNCTION    LMSetJournalRef
  1896.     ENDIF
  1897.  
  1898. ;
  1899. ; pascal SInt16 LMGetCrsrThresh(void)
  1900. ;
  1901.     IF ¬ GENERATINGCFM THEN
  1902.         Macro
  1903.         _LMGetCrsrThresh     &dest=(sp)
  1904.         move.w               $08EC,&dest
  1905.         EndM
  1906.     ELSE
  1907.         IMPORT_CFM_FUNCTION    LMGetCrsrThresh
  1908.     ENDIF
  1909.  
  1910. ;
  1911. ; pascal void LMSetCrsrThresh(SInt16 value)
  1912. ;
  1913.     IF ¬ GENERATINGCFM THEN
  1914.         Macro
  1915.         _LMSetCrsrThresh     &src=(sp)+
  1916.         move.w               &src,$08EC
  1917.         EndM
  1918.     ELSE
  1919.         IMPORT_CFM_FUNCTION    LMSetCrsrThresh
  1920.     ENDIF
  1921.  
  1922. ;
  1923. ; pascal UniversalProcPtr LMGetJFetch(void)
  1924. ;
  1925.     IF ¬ GENERATINGCFM THEN
  1926.         Macro
  1927.         _LMGetJFetch         &dest=(sp)
  1928.         move.l               $08F4,&dest
  1929.         EndM
  1930.     ELSE
  1931.         IMPORT_CFM_FUNCTION    LMGetJFetch
  1932.     ENDIF
  1933.  
  1934. ;
  1935. ; pascal void LMSetJFetch(UniversalProcPtr value)
  1936. ;
  1937.     IF ¬ GENERATINGCFM THEN
  1938.         Macro
  1939.         _LMSetJFetch         &src=(sp)+
  1940.         move.l               &src,$08F4
  1941.         EndM
  1942.     ELSE
  1943.         IMPORT_CFM_FUNCTION    LMSetJFetch
  1944.     ENDIF
  1945.  
  1946. ;
  1947. ; pascal UniversalProcPtr LMGetJStash(void)
  1948. ;
  1949.     IF ¬ GENERATINGCFM THEN
  1950.         Macro
  1951.         _LMGetJStash         &dest=(sp)
  1952.         move.l               $08F8,&dest
  1953.         EndM
  1954.     ELSE
  1955.         IMPORT_CFM_FUNCTION    LMGetJStash
  1956.     ENDIF
  1957.  
  1958. ;
  1959. ; pascal void LMSetJStash(UniversalProcPtr value)
  1960. ;
  1961.     IF ¬ GENERATINGCFM THEN
  1962.         Macro
  1963.         _LMSetJStash         &src=(sp)+
  1964.         move.l               &src,$08F8
  1965.         EndM
  1966.     ELSE
  1967.         IMPORT_CFM_FUNCTION    LMSetJStash
  1968.     ENDIF
  1969.  
  1970. ;
  1971. ; pascal UniversalProcPtr LMGetJIODone(void)
  1972. ;
  1973.     IF ¬ GENERATINGCFM THEN
  1974.         Macro
  1975.         _LMGetJIODone        &dest=(sp)
  1976.         move.l               $08FC,&dest
  1977.         EndM
  1978.     ELSE
  1979.         IMPORT_CFM_FUNCTION    LMGetJIODone
  1980.     ENDIF
  1981.  
  1982. ;
  1983. ; pascal void LMSetJIODone(UniversalProcPtr value)
  1984. ;
  1985.     IF ¬ GENERATINGCFM THEN
  1986.         Macro
  1987.         _LMSetJIODone        &src=(sp)+
  1988.         move.l               &src,$08FC
  1989.         EndM
  1990.     ELSE
  1991.         IMPORT_CFM_FUNCTION    LMSetJIODone
  1992.     ENDIF
  1993.  
  1994. ;
  1995. ; pascal SInt16 LMGetCurApRefNum(void)
  1996. ;
  1997.     IF ¬ GENERATINGCFM THEN
  1998.         Macro
  1999.         _LMGetCurApRefNum    &dest=(sp)
  2000.         move.w               $0900,&dest
  2001.         EndM
  2002.     ELSE
  2003.         IMPORT_CFM_FUNCTION    LMGetCurApRefNum
  2004.     ENDIF
  2005.  
  2006. ;
  2007. ; pascal void LMSetCurApRefNum(SInt16 value)
  2008. ;
  2009.     IF ¬ GENERATINGCFM THEN
  2010.         Macro
  2011.         _LMSetCurApRefNum    &src=(sp)+
  2012.         move.w               &src,$0900
  2013.         EndM
  2014.     ELSE
  2015.         IMPORT_CFM_FUNCTION    LMSetCurApRefNum
  2016.     ENDIF
  2017.  
  2018. ;
  2019. ; pascal Ptr LMGetCurrentA5(void)
  2020. ;
  2021.     IF ¬ GENERATINGCFM THEN
  2022.         Macro
  2023.         _LMGetCurrentA5      &dest=(sp)
  2024.         move.l               $0904,&dest
  2025.         EndM
  2026.     ELSE
  2027.         IMPORT_CFM_FUNCTION    LMGetCurrentA5
  2028.     ENDIF
  2029.  
  2030. ;
  2031. ; pascal void LMSetCurrentA5(Ptr value)
  2032. ;
  2033.     IF ¬ GENERATINGCFM THEN
  2034.         Macro
  2035.         _LMSetCurrentA5      &src=(sp)+
  2036.         move.l               &src,$0904
  2037.         EndM
  2038.     ELSE
  2039.         IMPORT_CFM_FUNCTION    LMSetCurrentA5
  2040.     ENDIF
  2041.  
  2042. ;
  2043. ; pascal Ptr LMGetCurStackBase(void)
  2044. ;
  2045.     IF ¬ GENERATINGCFM THEN
  2046.         Macro
  2047.         _LMGetCurStackBase   &dest=(sp)
  2048.         move.l               $0908,&dest
  2049.         EndM
  2050.     ELSE
  2051.         IMPORT_CFM_FUNCTION    LMGetCurStackBase
  2052.     ENDIF
  2053.  
  2054. ;
  2055. ; pascal void LMSetCurStackBase(Ptr value)
  2056. ;
  2057.     IF ¬ GENERATINGCFM THEN
  2058.         Macro
  2059.         _LMSetCurStackBase   &src=(sp)+
  2060.         move.l               &src,$0908
  2061.         EndM
  2062.     ELSE
  2063.         IMPORT_CFM_FUNCTION    LMSetCurStackBase
  2064.     ENDIF
  2065.  
  2066. ;
  2067. ; pascal SInt16 LMGetCurJTOffset(void)
  2068. ;
  2069.     IF ¬ GENERATINGCFM THEN
  2070.         Macro
  2071.         _LMGetCurJTOffset    &dest=(sp)
  2072.         move.w               $0934,&dest
  2073.         EndM
  2074.     ELSE
  2075.         IMPORT_CFM_FUNCTION    LMGetCurJTOffset
  2076.     ENDIF
  2077.  
  2078. ;
  2079. ; pascal void LMSetCurJTOffset(SInt16 value)
  2080. ;
  2081.     IF ¬ GENERATINGCFM THEN
  2082.         Macro
  2083.         _LMSetCurJTOffset    &src=(sp)+
  2084.         move.w               &src,$0934
  2085.         EndM
  2086.     ELSE
  2087.         IMPORT_CFM_FUNCTION    LMSetCurJTOffset
  2088.     ENDIF
  2089.  
  2090. ;
  2091. ; pascal SInt16 LMGetCurPageOption(void)
  2092. ;
  2093.     IF ¬ GENERATINGCFM THEN
  2094.         Macro
  2095.         _LMGetCurPageOption  &dest=(sp)
  2096.         move.w               $0936,&dest
  2097.         EndM
  2098.     ELSE
  2099.         IMPORT_CFM_FUNCTION    LMGetCurPageOption
  2100.     ENDIF
  2101.  
  2102. ;
  2103. ; pascal void LMSetCurPageOption(SInt16 value)
  2104. ;
  2105.     IF ¬ GENERATINGCFM THEN
  2106.         Macro
  2107.         _LMSetCurPageOption  &src=(sp)+
  2108.         move.w               &src,$0936
  2109.         EndM
  2110.     ELSE
  2111.         IMPORT_CFM_FUNCTION    LMSetCurPageOption
  2112.     ENDIF
  2113.  
  2114. ;
  2115. ; pascal UInt8 LMGetHiliteMode(void)
  2116. ;
  2117.     IF ¬ GENERATINGCFM THEN
  2118.         Macro
  2119.         _LMGetHiliteMode     &dest=(sp)
  2120.         move.b               $0938,&dest
  2121.         EndM
  2122.     ELSE
  2123.         IMPORT_CFM_FUNCTION    LMGetHiliteMode
  2124.     ENDIF
  2125.  
  2126. ;
  2127. ; pascal void LMSetHiliteMode(UInt8 value)
  2128. ;
  2129.     IF ¬ GENERATINGCFM THEN
  2130.         Macro
  2131.         _LMSetHiliteMode     &src=(sp)+
  2132.         move.b               &src,$0938
  2133.         EndM
  2134.     ELSE
  2135.         IMPORT_CFM_FUNCTION    LMSetHiliteMode
  2136.     ENDIF
  2137.  
  2138. ;
  2139. ; pascal SInt16 LMGetPrintErr(void)
  2140. ;
  2141.     IF ¬ GENERATINGCFM THEN
  2142.         Macro
  2143.         _LMGetPrintErr       &dest=(sp)
  2144.         move.w               $0944,&dest
  2145.         EndM
  2146.     ELSE
  2147.         IMPORT_CFM_FUNCTION    LMGetPrintErr
  2148.     ENDIF
  2149.  
  2150. ;
  2151. ; pascal void LMSetPrintErr(SInt16 value)
  2152. ;
  2153.     IF ¬ GENERATINGCFM THEN
  2154.         Macro
  2155.         _LMSetPrintErr       &src=(sp)+
  2156.         move.w               &src,$0944
  2157.         EndM
  2158.     ELSE
  2159.         IMPORT_CFM_FUNCTION    LMSetPrintErr
  2160.     ENDIF
  2161.  
  2162. ;
  2163. ; pascal SInt32 LMGetScrapSize(void)
  2164. ;
  2165.     IF ¬ GENERATINGCFM THEN
  2166.         Macro
  2167.         _LMGetScrapSize      &dest=(sp)
  2168.         move.l               $0960,&dest
  2169.         EndM
  2170.     ELSE
  2171.         IMPORT_CFM_FUNCTION    LMGetScrapSize
  2172.     ENDIF
  2173.  
  2174. ;
  2175. ; pascal void LMSetScrapSize(SInt32 value)
  2176. ;
  2177.     IF ¬ GENERATINGCFM THEN
  2178.         Macro
  2179.         _LMSetScrapSize      &src=(sp)+
  2180.         move.l               &src,$0960
  2181.         EndM
  2182.     ELSE
  2183.         IMPORT_CFM_FUNCTION    LMSetScrapSize
  2184.     ENDIF
  2185.  
  2186. ;
  2187. ; pascal Handle LMGetScrapHandle(void)
  2188. ;
  2189.     IF ¬ GENERATINGCFM THEN
  2190.         Macro
  2191.         _LMGetScrapHandle    &dest=(sp)
  2192.         move.l               $0964,&dest
  2193.         EndM
  2194.     ELSE
  2195.         IMPORT_CFM_FUNCTION    LMGetScrapHandle
  2196.     ENDIF
  2197.  
  2198. ;
  2199. ; pascal void LMSetScrapHandle(Handle value)
  2200. ;
  2201.     IF ¬ GENERATINGCFM THEN
  2202.         Macro
  2203.         _LMSetScrapHandle    &src=(sp)+
  2204.         move.l               &src,$0964
  2205.         EndM
  2206.     ELSE
  2207.         IMPORT_CFM_FUNCTION    LMSetScrapHandle
  2208.     ENDIF
  2209.  
  2210. ;
  2211. ; pascal SInt16 LMGetScrapCount(void)
  2212. ;
  2213.     IF ¬ GENERATINGCFM THEN
  2214.         Macro
  2215.         _LMGetScrapCount     &dest=(sp)
  2216.         move.w               $0968,&dest
  2217.         EndM
  2218.     ELSE
  2219.         IMPORT_CFM_FUNCTION    LMGetScrapCount
  2220.     ENDIF
  2221.  
  2222. ;
  2223. ; pascal void LMSetScrapCount(SInt16 value)
  2224. ;
  2225.     IF ¬ GENERATINGCFM THEN
  2226.         Macro
  2227.         _LMSetScrapCount     &src=(sp)+
  2228.         move.w               &src,$0968
  2229.         EndM
  2230.     ELSE
  2231.         IMPORT_CFM_FUNCTION    LMSetScrapCount
  2232.     ENDIF
  2233.  
  2234. ;
  2235. ; pascal SInt16 LMGetScrapState(void)
  2236. ;
  2237.     IF ¬ GENERATINGCFM THEN
  2238.         Macro
  2239.         _LMGetScrapState     &dest=(sp)
  2240.         move.w               $096A,&dest
  2241.         EndM
  2242.     ELSE
  2243.         IMPORT_CFM_FUNCTION    LMGetScrapState
  2244.     ENDIF
  2245.  
  2246. ;
  2247. ; pascal void LMSetScrapState(SInt16 value)
  2248. ;
  2249.     IF ¬ GENERATINGCFM THEN
  2250.         Macro
  2251.         _LMSetScrapState     &src=(sp)+
  2252.         move.w               &src,$096A
  2253.         EndM
  2254.     ELSE
  2255.         IMPORT_CFM_FUNCTION    LMSetScrapState
  2256.     ENDIF
  2257.  
  2258. ;
  2259. ; pascal StringPtr LMGetScrapName(void)
  2260. ;
  2261.     IF ¬ GENERATINGCFM THEN
  2262.         Macro
  2263.         _LMGetScrapName      &dest=(sp)
  2264.         move.l               $096C,&dest
  2265.         EndM
  2266.     ELSE
  2267.         IMPORT_CFM_FUNCTION    LMGetScrapName
  2268.     ENDIF
  2269.  
  2270. ;
  2271. ; pascal void LMSetScrapName(StringPtr value)
  2272. ;
  2273.     IF ¬ GENERATINGCFM THEN
  2274.         Macro
  2275.         _LMSetScrapName      &src=(sp)+
  2276.         move.l               &src,$096C
  2277.         EndM
  2278.     ELSE
  2279.         IMPORT_CFM_FUNCTION    LMSetScrapName
  2280.     ENDIF
  2281.  
  2282. ;
  2283. ; pascal Handle LMGetROMFont0(void)
  2284. ;
  2285.     IF ¬ GENERATINGCFM THEN
  2286.         Macro
  2287.         _LMGetROMFont0       &dest=(sp)
  2288.         move.l               $0980,&dest
  2289.         EndM
  2290.     ELSE
  2291.         IMPORT_CFM_FUNCTION    LMGetROMFont0
  2292.     ENDIF
  2293.  
  2294. ;
  2295. ; pascal void LMSetROMFont0(Handle value)
  2296. ;
  2297.     IF ¬ GENERATINGCFM THEN
  2298.         Macro
  2299.         _LMSetROMFont0       &src=(sp)+
  2300.         move.l               &src,$0980
  2301.         EndM
  2302.     ELSE
  2303.         IMPORT_CFM_FUNCTION    LMSetROMFont0
  2304.     ENDIF
  2305.  
  2306. ;
  2307. ; pascal SInt16 LMGetApFontID(void)
  2308. ;
  2309.     IF ¬ GENERATINGCFM THEN
  2310.         Macro
  2311.         _LMGetApFontID       &dest=(sp)
  2312.         move.w               $0984,&dest
  2313.         EndM
  2314.     ELSE
  2315.         IMPORT_CFM_FUNCTION    LMGetApFontID
  2316.     ENDIF
  2317.  
  2318. ;
  2319. ; pascal void LMSetApFontID(SInt16 value)
  2320. ;
  2321.     IF ¬ GENERATINGCFM THEN
  2322.         Macro
  2323.         _LMSetApFontID       &src=(sp)+
  2324.         move.w               &src,$0984
  2325.         EndM
  2326.     ELSE
  2327.         IMPORT_CFM_FUNCTION    LMSetApFontID
  2328.     ENDIF
  2329.  
  2330. ;
  2331. ; pascal WindowRef LMGetWindowList(void)
  2332. ;
  2333.     IF ¬ GENERATINGCFM THEN
  2334.         Macro
  2335.         _LMGetWindowList     &dest=(sp)
  2336.         move.l               $09D6,&dest
  2337.         EndM
  2338.     ELSE
  2339.         IMPORT_CFM_FUNCTION    LMGetWindowList
  2340.     ENDIF
  2341.  
  2342. ;
  2343. ; pascal SInt16 LMGetSaveUpdate(void)
  2344. ;
  2345.     IF ¬ GENERATINGCFM THEN
  2346.         Macro
  2347.         _LMGetSaveUpdate     &dest=(sp)
  2348.         move.w               $09DA,&dest
  2349.         EndM
  2350.     ELSE
  2351.         IMPORT_CFM_FUNCTION    LMGetSaveUpdate
  2352.     ENDIF
  2353.  
  2354. ;
  2355. ; pascal void LMSetSaveUpdate(SInt16 value)
  2356. ;
  2357.     IF ¬ GENERATINGCFM THEN
  2358.         Macro
  2359.         _LMSetSaveUpdate     &src=(sp)+
  2360.         move.w               &src,$09DA
  2361.         EndM
  2362.     ELSE
  2363.         IMPORT_CFM_FUNCTION    LMSetSaveUpdate
  2364.     ENDIF
  2365.  
  2366. ;
  2367. ; pascal SInt16 LMGetPaintWhite(void)
  2368. ;
  2369.     IF ¬ GENERATINGCFM THEN
  2370.         Macro
  2371.         _LMGetPaintWhite     &dest=(sp)
  2372.         move.w               $09DC,&dest
  2373.         EndM
  2374.     ELSE
  2375.         IMPORT_CFM_FUNCTION    LMGetPaintWhite
  2376.     ENDIF
  2377.  
  2378. ;
  2379. ; pascal void LMSetPaintWhite(SInt16 value)
  2380. ;
  2381.     IF ¬ GENERATINGCFM THEN
  2382.         Macro
  2383.         _LMSetPaintWhite     &src=(sp)+
  2384.         move.w               &src,$09DC
  2385.         EndM
  2386.     ELSE
  2387.         IMPORT_CFM_FUNCTION    LMSetPaintWhite
  2388.     ENDIF
  2389.  
  2390. ;
  2391. ; pascal GrafPtr LMGetWMgrPort(void)
  2392. ;
  2393.     IF ¬ GENERATINGCFM THEN
  2394.         Macro
  2395.         _LMGetWMgrPort       &dest=(sp)
  2396.         move.l               $09DE,&dest
  2397.         EndM
  2398.     ELSE
  2399.         IMPORT_CFM_FUNCTION    LMGetWMgrPort
  2400.     ENDIF
  2401.  
  2402. ;
  2403. ; pascal void LMSetWMgrPort(GrafPtr value)
  2404. ;
  2405.     IF ¬ GENERATINGCFM THEN
  2406.         Macro
  2407.         _LMSetWMgrPort       &src=(sp)+
  2408.         move.l               &src,$09DE
  2409.         EndM
  2410.     ELSE
  2411.         IMPORT_CFM_FUNCTION    LMSetWMgrPort
  2412.     ENDIF
  2413.  
  2414. ;
  2415. ; pascal RgnHandle LMGetGrayRgn(void)
  2416. ;
  2417.     IF ¬ GENERATINGCFM THEN
  2418.         Macro
  2419.         _LMGetGrayRgn        &dest=(sp)
  2420.         move.l               $09EE,&dest
  2421.         EndM
  2422.     ELSE
  2423.         IMPORT_CFM_FUNCTION    LMGetGrayRgn
  2424.     ENDIF
  2425.  
  2426. ;
  2427. ; pascal UniversalProcPtr LMGetDragHook(void)
  2428. ;
  2429.     IF ¬ GENERATINGCFM THEN
  2430.         Macro
  2431.         _LMGetDragHook       &dest=(sp)
  2432.         move.l               $09F6,&dest
  2433.         EndM
  2434.     ELSE
  2435.         IMPORT_CFM_FUNCTION    LMGetDragHook
  2436.     ENDIF
  2437.  
  2438. ;
  2439. ; pascal void LMSetDragHook(UniversalProcPtr value)
  2440. ;
  2441.     IF ¬ GENERATINGCFM THEN
  2442.         Macro
  2443.         _LMSetDragHook       &src=(sp)+
  2444.         move.l               &src,$09F6
  2445.         EndM
  2446.     ELSE
  2447.         IMPORT_CFM_FUNCTION    LMSetDragHook
  2448.     ENDIF
  2449.  
  2450. ;
  2451. ; To best work with future versions of the window manager,
  2452. ; avoid using anything not defined with STRICT_WINDOWS
  2453. ; set to true.  Most, if not all of these will still
  2454. ; be supported in the next major version of the window manager
  2455. ; but will trigger non-optimal compatibility code paths that
  2456. ; should be avoided if possible.
  2457. ;
  2458.     IF ¬ STRICT_WINDOWS  THEN
  2459. ;
  2460. ; There is no reason to set the window list directly.
  2461. ; Use BringToFront and SendBehind.
  2462. ;
  2463. ; If you need to do floating windows, avoid using GhostWindow 
  2464. ; and especially avoid patching the window manager.
  2465. ;
  2466. ; See Dean Yu's article in Develop 15 about how to implement floating
  2467. ; windows using low-level window manager calls.  The next generation
  2468. ; Macintosh Window Manager will have built-in support for floating
  2469. ; and modal windows.
  2470. ;
  2471. ;
  2472. ; pascal void LMSetWindowList(WindowRef value)
  2473. ;
  2474.     IF ¬ GENERATINGCFM THEN
  2475.         Macro
  2476.         _LMSetWindowList     &src=(sp)+
  2477.         move.l               &src,$09D6
  2478.         EndM
  2479.     ELSE
  2480.         IMPORT_CFM_FUNCTION    LMSetWindowList
  2481.     ENDIF
  2482.  
  2483. ;
  2484. ; pascal WindowRef LMGetGhostWindow(void)
  2485. ;
  2486.     IF ¬ GENERATINGCFM THEN
  2487.         Macro
  2488.         _LMGetGhostWindow    &dest=(sp)
  2489.         move.l               $0A84,&dest
  2490.         EndM
  2491.     ELSE
  2492.         IMPORT_CFM_FUNCTION    LMGetGhostWindow
  2493.     ENDIF
  2494.  
  2495. ;
  2496. ; pascal void LMSetGhostWindow(WindowRef value)
  2497. ;
  2498.     IF ¬ GENERATINGCFM THEN
  2499.         Macro
  2500.         _LMSetGhostWindow    &src=(sp)+
  2501.         move.l               &src,$0A84
  2502.         EndM
  2503.     ELSE
  2504.         IMPORT_CFM_FUNCTION    LMSetGhostWindow
  2505.     ENDIF
  2506.  
  2507. ;
  2508. ; The auxiliary window record list will be empty in future
  2509. ; versions of the window manager.  There is no reason to 
  2510. ; walk it or change it. 
  2511. ;
  2512. ;
  2513. ; pascal AuxWinHandle LMGetAuxWinHead(void)
  2514. ;
  2515.     IF ¬ GENERATINGCFM THEN
  2516.         Macro
  2517.         _LMGetAuxWinHead     &dest=(sp)
  2518.         move.l               $0CD0,&dest
  2519.         EndM
  2520.     ELSE
  2521.         IMPORT_CFM_FUNCTION    LMGetAuxWinHead
  2522.     ENDIF
  2523.  
  2524. ;
  2525. ; pascal void LMSetAuxWinHead(AuxWinHandle value)
  2526. ;
  2527.     IF ¬ GENERATINGCFM THEN
  2528.         Macro
  2529.         _LMSetAuxWinHead     &src=(sp)+
  2530.         move.l               &src,$0CD0
  2531.         EndM
  2532.     ELSE
  2533.         IMPORT_CFM_FUNCTION    LMSetAuxWinHead
  2534.     ENDIF
  2535.  
  2536. ;
  2537. ; Please rely on the event manager to deliver activate and 
  2538. ; deactivate events and on the window manager to generate them.
  2539. ;
  2540. ; The next generation window manager will queue these events
  2541. ; rather than just slamming these lowmems with the latest
  2542. ; generated event, so it pays to rely on the event manager.
  2543. ;
  2544. ;
  2545. ; pascal WindowRef LMGetCurActivate(void)
  2546. ;
  2547.     IF ¬ GENERATINGCFM THEN
  2548.         Macro
  2549.         _LMGetCurActivate    &dest=(sp)
  2550.         move.l               $0A64,&dest
  2551.         EndM
  2552.     ELSE
  2553.         IMPORT_CFM_FUNCTION    LMGetCurActivate
  2554.     ENDIF
  2555.  
  2556. ;
  2557. ; pascal void LMSetCurActivate(WindowRef value)
  2558. ;
  2559.     IF ¬ GENERATINGCFM THEN
  2560.         Macro
  2561.         _LMSetCurActivate    &src=(sp)+
  2562.         move.l               &src,$0A64
  2563.         EndM
  2564.     ELSE
  2565.         IMPORT_CFM_FUNCTION    LMSetCurActivate
  2566.     ENDIF
  2567.  
  2568. ;
  2569. ; pascal WindowRef LMGetCurDeactive(void)
  2570. ;
  2571.     IF ¬ GENERATINGCFM THEN
  2572.         Macro
  2573.         _LMGetCurDeactive    &dest=(sp)
  2574.         move.l               $0A68,&dest
  2575.         EndM
  2576.     ELSE
  2577.         IMPORT_CFM_FUNCTION    LMGetCurDeactive
  2578.     ENDIF
  2579.  
  2580. ;
  2581. ; pascal void LMSetCurDeactive(WindowRef value)
  2582. ;
  2583.     IF ¬ GENERATINGCFM THEN
  2584.         Macro
  2585.         _LMSetCurDeactive    &src=(sp)+
  2586.         move.l               &src,$0A68
  2587.         EndM
  2588.     ELSE
  2589.         IMPORT_CFM_FUNCTION    LMSetCurDeactive
  2590.     ENDIF
  2591.  
  2592. ;
  2593. ; pascal RgnHandle LMGetOldStructure(void)
  2594. ;
  2595.     IF ¬ GENERATINGCFM THEN
  2596.         Macro
  2597.         _LMGetOldStructure   &dest=(sp)
  2598.         move.l               $09E6,&dest
  2599.         EndM
  2600.     ELSE
  2601.         IMPORT_CFM_FUNCTION    LMGetOldStructure
  2602.     ENDIF
  2603.  
  2604. ;
  2605. ; pascal void LMSetOldStructure(RgnHandle value)
  2606. ;
  2607.     IF ¬ GENERATINGCFM THEN
  2608.         Macro
  2609.         _LMSetOldStructure   &src=(sp)+
  2610.         move.l               &src,$09E6
  2611.         EndM
  2612.     ELSE
  2613.         IMPORT_CFM_FUNCTION    LMSetOldStructure
  2614.     ENDIF
  2615.  
  2616. ;
  2617. ; pascal RgnHandle LMGetOldContent(void)
  2618. ;
  2619.     IF ¬ GENERATINGCFM THEN
  2620.         Macro
  2621.         _LMGetOldContent     &dest=(sp)
  2622.         move.l               $09EA,&dest
  2623.         EndM
  2624.     ELSE
  2625.         IMPORT_CFM_FUNCTION    LMGetOldContent
  2626.     ENDIF
  2627.  
  2628. ;
  2629. ; pascal void LMSetOldContent(RgnHandle value)
  2630. ;
  2631.     IF ¬ GENERATINGCFM THEN
  2632.         Macro
  2633.         _LMSetOldContent     &src=(sp)+
  2634.         move.l               &src,$09EA
  2635.         EndM
  2636.     ELSE
  2637.         IMPORT_CFM_FUNCTION    LMSetOldContent
  2638.     ENDIF
  2639.  
  2640. ;
  2641. ; Please don't mess with the gray region.  There has
  2642. ; to be a better way.  If not, please manipulate the
  2643. ; existing region, don't change the value of the lowmem.
  2644. ;
  2645. ;
  2646. ; pascal void LMSetGrayRgn(RgnHandle value)
  2647. ;
  2648.     IF ¬ GENERATINGCFM THEN
  2649.         Macro
  2650.         _LMSetGrayRgn        &src=(sp)+
  2651.         move.l               &src,$09EE
  2652.         EndM
  2653.     ELSE
  2654.         IMPORT_CFM_FUNCTION    LMSetGrayRgn
  2655.     ENDIF
  2656.  
  2657. ;
  2658. ; pascal RgnHandle LMGetSaveVisRgn(void)
  2659. ;
  2660.     IF ¬ GENERATINGCFM THEN
  2661.         Macro
  2662.         _LMGetSaveVisRgn     &dest=(sp)
  2663.         move.l               $09F2,&dest
  2664.         EndM
  2665.     ELSE
  2666.         IMPORT_CFM_FUNCTION    LMGetSaveVisRgn
  2667.     ENDIF
  2668.  
  2669. ;
  2670. ; pascal void LMSetSaveVisRgn(RgnHandle value)
  2671. ;
  2672.     IF ¬ GENERATINGCFM THEN
  2673.         Macro
  2674.         _LMSetSaveVisRgn     &src=(sp)+
  2675.         move.l               &src,$09F2
  2676.         EndM
  2677.     ELSE
  2678.         IMPORT_CFM_FUNCTION    LMSetSaveVisRgn
  2679.     ENDIF
  2680.  
  2681.     ENDIF
  2682. ;
  2683. ; pascal SInt32 LMGetOneOne(void)
  2684. ;
  2685.     IF ¬ GENERATINGCFM THEN
  2686.         Macro
  2687.         _LMGetOneOne         &dest=(sp)
  2688.         move.l               $0A02,&dest
  2689.         EndM
  2690.     ELSE
  2691.         IMPORT_CFM_FUNCTION    LMGetOneOne
  2692.     ENDIF
  2693.  
  2694. ;
  2695. ; pascal void LMSetOneOne(SInt32 value)
  2696. ;
  2697.     IF ¬ GENERATINGCFM THEN
  2698.         Macro
  2699.         _LMSetOneOne         &src=(sp)+
  2700.         move.l               &src,$0A02
  2701.         EndM
  2702.     ELSE
  2703.         IMPORT_CFM_FUNCTION    LMSetOneOne
  2704.     ENDIF
  2705.  
  2706. ;
  2707. ; pascal SInt32 LMGetMinusOne(void)
  2708. ;
  2709.     IF ¬ GENERATINGCFM THEN
  2710.         Macro
  2711.         _LMGetMinusOne       &dest=(sp)
  2712.         move.l               $0A06,&dest
  2713.         EndM
  2714.     ELSE
  2715.         IMPORT_CFM_FUNCTION    LMGetMinusOne
  2716.     ENDIF
  2717.  
  2718. ;
  2719. ; pascal void LMSetMinusOne(SInt32 value)
  2720. ;
  2721.     IF ¬ GENERATINGCFM THEN
  2722.         Macro
  2723.         _LMSetMinusOne       &src=(sp)+
  2724.         move.l               &src,$0A06
  2725.         EndM
  2726.     ELSE
  2727.         IMPORT_CFM_FUNCTION    LMSetMinusOne
  2728.     ENDIF
  2729.  
  2730. ;
  2731. ; pascal SInt16 LMGetTopMenuItem(void)
  2732. ;
  2733.     IF ¬ GENERATINGCFM THEN
  2734.         Macro
  2735.         _LMGetTopMenuItem    &dest=(sp)
  2736.         move.w               $0A0A,&dest
  2737.         EndM
  2738.     ELSE
  2739.         IMPORT_CFM_FUNCTION    LMGetTopMenuItem
  2740.     ENDIF
  2741.  
  2742. ;
  2743. ; pascal void LMSetTopMenuItem(SInt16 value)
  2744. ;
  2745.     IF ¬ GENERATINGCFM THEN
  2746.         Macro
  2747.         _LMSetTopMenuItem    &src=(sp)+
  2748.         move.w               &src,$0A0A
  2749.         EndM
  2750.     ELSE
  2751.         IMPORT_CFM_FUNCTION    LMSetTopMenuItem
  2752.     ENDIF
  2753.  
  2754. ;
  2755. ; pascal SInt16 LMGetAtMenuBottom(void)
  2756. ;
  2757.     IF ¬ GENERATINGCFM THEN
  2758.         Macro
  2759.         _LMGetAtMenuBottom   &dest=(sp)
  2760.         move.w               $0A0C,&dest
  2761.         EndM
  2762.     ELSE
  2763.         IMPORT_CFM_FUNCTION    LMGetAtMenuBottom
  2764.     ENDIF
  2765.  
  2766. ;
  2767. ; pascal void LMSetAtMenuBottom(SInt16 value)
  2768. ;
  2769.     IF ¬ GENERATINGCFM THEN
  2770.         Macro
  2771.         _LMSetAtMenuBottom   &src=(sp)+
  2772.         move.w               &src,$0A0C
  2773.         EndM
  2774.     ELSE
  2775.         IMPORT_CFM_FUNCTION    LMSetAtMenuBottom
  2776.     ENDIF
  2777.  
  2778. ;
  2779. ; pascal Handle LMGetMenuList(void)
  2780. ;
  2781.     IF ¬ GENERATINGCFM THEN
  2782.         Macro
  2783.         _LMGetMenuList       &dest=(sp)
  2784.         move.l               $0A1C,&dest
  2785.         EndM
  2786.     ELSE
  2787.         IMPORT_CFM_FUNCTION    LMGetMenuList
  2788.     ENDIF
  2789.  
  2790. ;
  2791. ; pascal void LMSetMenuList(Handle value)
  2792. ;
  2793.     IF ¬ GENERATINGCFM THEN
  2794.         Macro
  2795.         _LMSetMenuList       &src=(sp)+
  2796.         move.l               &src,$0A1C
  2797.         EndM
  2798.     ELSE
  2799.         IMPORT_CFM_FUNCTION    LMSetMenuList
  2800.     ENDIF
  2801.  
  2802. ;
  2803. ; pascal SInt16 LMGetMBarEnable(void)
  2804. ;
  2805.     IF ¬ GENERATINGCFM THEN
  2806.         Macro
  2807.         _LMGetMBarEnable     &dest=(sp)
  2808.         move.w               $0A20,&dest
  2809.         EndM
  2810.     ELSE
  2811.         IMPORT_CFM_FUNCTION    LMGetMBarEnable
  2812.     ENDIF
  2813.  
  2814. ;
  2815. ; pascal void LMSetMBarEnable(SInt16 value)
  2816. ;
  2817.     IF ¬ GENERATINGCFM THEN
  2818.         Macro
  2819.         _LMSetMBarEnable     &src=(sp)+
  2820.         move.w               &src,$0A20
  2821.         EndM
  2822.     ELSE
  2823.         IMPORT_CFM_FUNCTION    LMSetMBarEnable
  2824.     ENDIF
  2825.  
  2826. ;
  2827. ; pascal SInt16 LMGetMenuFlash(void)
  2828. ;
  2829.     IF ¬ GENERATINGCFM THEN
  2830.         Macro
  2831.         _LMGetMenuFlash      &dest=(sp)
  2832.         move.w               $0A24,&dest
  2833.         EndM
  2834.     ELSE
  2835.         IMPORT_CFM_FUNCTION    LMGetMenuFlash
  2836.     ENDIF
  2837.  
  2838. ;
  2839. ; pascal void LMSetMenuFlash(SInt16 value)
  2840. ;
  2841.     IF ¬ GENERATINGCFM THEN
  2842.         Macro
  2843.         _LMSetMenuFlash      &src=(sp)+
  2844.         move.w               &src,$0A24
  2845.         EndM
  2846.     ELSE
  2847.         IMPORT_CFM_FUNCTION    LMSetMenuFlash
  2848.     ENDIF
  2849.  
  2850. ;
  2851. ; pascal SInt16 LMGetTheMenu(void)
  2852. ;
  2853.     IF ¬ GENERATINGCFM THEN
  2854.         Macro
  2855.         _LMGetTheMenu        &dest=(sp)
  2856.         move.w               $0A26,&dest
  2857.         EndM
  2858.     ELSE
  2859.         IMPORT_CFM_FUNCTION    LMGetTheMenu
  2860.     ENDIF
  2861.  
  2862. ;
  2863. ; pascal void LMSetTheMenu(SInt16 value)
  2864. ;
  2865.     IF ¬ GENERATINGCFM THEN
  2866.         Macro
  2867.         _LMSetTheMenu        &src=(sp)+
  2868.         move.w               &src,$0A26
  2869.         EndM
  2870.     ELSE
  2871.         IMPORT_CFM_FUNCTION    LMSetTheMenu
  2872.     ENDIF
  2873.  
  2874. ;
  2875. ; pascal UniversalProcPtr LMGetMBarHook(void)
  2876. ;
  2877.     IF ¬ GENERATINGCFM THEN
  2878.         Macro
  2879.         _LMGetMBarHook       &dest=(sp)
  2880.         move.l               $0A2C,&dest
  2881.         EndM
  2882.     ELSE
  2883.         IMPORT_CFM_FUNCTION    LMGetMBarHook
  2884.     ENDIF
  2885.  
  2886. ;
  2887. ; pascal void LMSetMBarHook(UniversalProcPtr value)
  2888. ;
  2889.     IF ¬ GENERATINGCFM THEN
  2890.         Macro
  2891.         _LMSetMBarHook       &src=(sp)+
  2892.         move.l               &src,$0A2C
  2893.         EndM
  2894.     ELSE
  2895.         IMPORT_CFM_FUNCTION    LMSetMBarHook
  2896.     ENDIF
  2897.  
  2898. ;
  2899. ; pascal UniversalProcPtr LMGetMenuHook(void)
  2900. ;
  2901.     IF ¬ GENERATINGCFM THEN
  2902.         Macro
  2903.         _LMGetMenuHook       &dest=(sp)
  2904.         move.l               $0A30,&dest
  2905.         EndM
  2906.     ELSE
  2907.         IMPORT_CFM_FUNCTION    LMGetMenuHook
  2908.     ENDIF
  2909.  
  2910. ;
  2911. ; pascal void LMSetMenuHook(UniversalProcPtr value)
  2912. ;
  2913.     IF ¬ GENERATINGCFM THEN
  2914.         Macro
  2915.         _LMSetMenuHook       &src=(sp)+
  2916.         move.l               &src,$0A30
  2917.         EndM
  2918.     ELSE
  2919.         IMPORT_CFM_FUNCTION    LMSetMenuHook
  2920.     ENDIF
  2921.  
  2922. ;
  2923. ; pascal Handle LMGetTopMapHndl(void)
  2924. ;
  2925.     IF ¬ GENERATINGCFM THEN
  2926.         Macro
  2927.         _LMGetTopMapHndl     &dest=(sp)
  2928.         move.l               $0A50,&dest
  2929.         EndM
  2930.     ELSE
  2931.         IMPORT_CFM_FUNCTION    LMGetTopMapHndl
  2932.     ENDIF
  2933.  
  2934. ;
  2935. ; pascal void LMSetTopMapHndl(Handle value)
  2936. ;
  2937.     IF ¬ GENERATINGCFM THEN
  2938.         Macro
  2939.         _LMSetTopMapHndl     &src=(sp)+
  2940.         move.l               &src,$0A50
  2941.         EndM
  2942.     ELSE
  2943.         IMPORT_CFM_FUNCTION    LMSetTopMapHndl
  2944.     ENDIF
  2945.  
  2946. ;
  2947. ; pascal Handle LMGetSysMapHndl(void)
  2948. ;
  2949.     IF ¬ GENERATINGCFM THEN
  2950.         Macro
  2951.         _LMGetSysMapHndl     &dest=(sp)
  2952.         move.l               $0A54,&dest
  2953.         EndM
  2954.     ELSE
  2955.         IMPORT_CFM_FUNCTION    LMGetSysMapHndl
  2956.     ENDIF
  2957.  
  2958. ;
  2959. ; pascal void LMSetSysMapHndl(Handle value)
  2960. ;
  2961.     IF ¬ GENERATINGCFM THEN
  2962.         Macro
  2963.         _LMSetSysMapHndl     &src=(sp)+
  2964.         move.l               &src,$0A54
  2965.         EndM
  2966.     ELSE
  2967.         IMPORT_CFM_FUNCTION    LMSetSysMapHndl
  2968.     ENDIF
  2969.  
  2970. ;
  2971. ; pascal SInt16 LMGetSysMap(void)
  2972. ;
  2973.     IF ¬ GENERATINGCFM THEN
  2974.         Macro
  2975.         _LMGetSysMap         &dest=(sp)
  2976.         move.w               $0A58,&dest
  2977.         EndM
  2978.     ELSE
  2979.         IMPORT_CFM_FUNCTION    LMGetSysMap
  2980.     ENDIF
  2981.  
  2982. ;
  2983. ; pascal void LMSetSysMap(SInt16 value)
  2984. ;
  2985.     IF ¬ GENERATINGCFM THEN
  2986.         Macro
  2987.         _LMSetSysMap         &src=(sp)+
  2988.         move.w               &src,$0A58
  2989.         EndM
  2990.     ELSE
  2991.         IMPORT_CFM_FUNCTION    LMSetSysMap
  2992.     ENDIF
  2993.  
  2994. ;
  2995. ; pascal SInt16 LMGetCurMap(void)
  2996. ;
  2997.     IF ¬ GENERATINGCFM THEN
  2998.         Macro
  2999.         _LMGetCurMap         &dest=(sp)
  3000.         move.w               $0A5A,&dest
  3001.         EndM
  3002.     ELSE
  3003.         IMPORT_CFM_FUNCTION    LMGetCurMap
  3004.     ENDIF
  3005.  
  3006. ;
  3007. ; pascal void LMSetCurMap(SInt16 value)
  3008. ;
  3009.     IF ¬ GENERATINGCFM THEN
  3010.         Macro
  3011.         _LMSetCurMap         &src=(sp)+
  3012.         move.w               &src,$0A5A
  3013.         EndM
  3014.     ELSE
  3015.         IMPORT_CFM_FUNCTION    LMSetCurMap
  3016.     ENDIF
  3017.  
  3018. ;
  3019. ; pascal UInt8 LMGetResLoad(void)
  3020. ;
  3021.     IF ¬ GENERATINGCFM THEN
  3022.         Macro
  3023.         _LMGetResLoad        &dest=(sp)
  3024.         move.b               $0A5E,&dest
  3025.         EndM
  3026.     ELSE
  3027.         IMPORT_CFM_FUNCTION    LMGetResLoad
  3028.     ENDIF
  3029.  
  3030. ;
  3031. ; pascal void LMSetResLoad(UInt8 value)
  3032. ;
  3033.     IF ¬ GENERATINGCFM THEN
  3034.         Macro
  3035.         _LMSetResLoad        &src=(sp)+
  3036.         move.b               &src,$0A5E
  3037.         EndM
  3038.     ELSE
  3039.         IMPORT_CFM_FUNCTION    LMSetResLoad
  3040.     ENDIF
  3041.  
  3042. ;
  3043. ; pascal SInt16 LMGetResErr(void)
  3044. ;
  3045.     IF ¬ GENERATINGCFM THEN
  3046.         Macro
  3047.         _LMGetResErr         &dest=(sp)
  3048.         move.w               $0A60,&dest
  3049.         EndM
  3050.     ELSE
  3051.         IMPORT_CFM_FUNCTION    LMGetResErr
  3052.     ENDIF
  3053.  
  3054. ;
  3055. ; pascal void LMSetResErr(SInt16 value)
  3056. ;
  3057.     IF ¬ GENERATINGCFM THEN
  3058.         Macro
  3059.         _LMSetResErr         &src=(sp)+
  3060.         move.w               &src,$0A60
  3061.         EndM
  3062.     ELSE
  3063.         IMPORT_CFM_FUNCTION    LMSetResErr
  3064.     ENDIF
  3065.  
  3066. ;
  3067. ; pascal UInt8 LMGetFScaleDisable(void)
  3068. ;
  3069.     IF ¬ GENERATINGCFM THEN
  3070.         Macro
  3071.         _LMGetFScaleDisable  &dest=(sp)
  3072.         move.b               $0A63,&dest
  3073.         EndM
  3074.     ELSE
  3075.         IMPORT_CFM_FUNCTION    LMGetFScaleDisable
  3076.     ENDIF
  3077.  
  3078. ;
  3079. ; pascal void LMSetFScaleDisable(UInt8 value)
  3080. ;
  3081.     IF ¬ GENERATINGCFM THEN
  3082.         Macro
  3083.         _LMSetFScaleDisable  &src=(sp)+
  3084.         move.b               &src,$0A63
  3085.         EndM
  3086.     ELSE
  3087.         IMPORT_CFM_FUNCTION    LMSetFScaleDisable
  3088.     ENDIF
  3089.  
  3090. ;
  3091. ; pascal UniversalProcPtr LMGetDeskHook(void)
  3092. ;
  3093.     IF ¬ GENERATINGCFM THEN
  3094.         Macro
  3095.         _LMGetDeskHook       &dest=(sp)
  3096.         move.l               $0A6C,&dest
  3097.         EndM
  3098.     ELSE
  3099.         IMPORT_CFM_FUNCTION    LMGetDeskHook
  3100.     ENDIF
  3101.  
  3102. ;
  3103. ; pascal void LMSetDeskHook(UniversalProcPtr value)
  3104. ;
  3105.     IF ¬ GENERATINGCFM THEN
  3106.         Macro
  3107.         _LMSetDeskHook       &src=(sp)+
  3108.         move.l               &src,$0A6C
  3109.         EndM
  3110.     ELSE
  3111.         IMPORT_CFM_FUNCTION    LMSetDeskHook
  3112.     ENDIF
  3113.  
  3114. ;
  3115. ; pascal UniversalProcPtr LMGetTEDoText(void)
  3116. ;
  3117.     IF ¬ GENERATINGCFM THEN
  3118.         Macro
  3119.         _LMGetTEDoText       &dest=(sp)
  3120.         move.l               $0A70,&dest
  3121.         EndM
  3122.     ELSE
  3123.         IMPORT_CFM_FUNCTION    LMGetTEDoText
  3124.     ENDIF
  3125.  
  3126. ;
  3127. ; pascal void LMSetTEDoText(UniversalProcPtr value)
  3128. ;
  3129.     IF ¬ GENERATINGCFM THEN
  3130.         Macro
  3131.         _LMSetTEDoText       &src=(sp)+
  3132.         move.l               &src,$0A70
  3133.         EndM
  3134.     ELSE
  3135.         IMPORT_CFM_FUNCTION    LMSetTEDoText
  3136.     ENDIF
  3137.  
  3138. ;
  3139. ; pascal UniversalProcPtr LMGetTERecal(void)
  3140. ;
  3141.     IF ¬ GENERATINGCFM THEN
  3142.         Macro
  3143.         _LMGetTERecal        &dest=(sp)
  3144.         move.l               $0A74,&dest
  3145.         EndM
  3146.     ELSE
  3147.         IMPORT_CFM_FUNCTION    LMGetTERecal
  3148.     ENDIF
  3149.  
  3150. ;
  3151. ; pascal void LMSetTERecal(UniversalProcPtr value)
  3152. ;
  3153.     IF ¬ GENERATINGCFM THEN
  3154.         Macro
  3155.         _LMSetTERecal        &src=(sp)+
  3156.         move.l               &src,$0A74
  3157.         EndM
  3158.     ELSE
  3159.         IMPORT_CFM_FUNCTION    LMSetTERecal
  3160.     ENDIF
  3161.  
  3162. ;
  3163. ; pascal UniversalProcPtr LMGetResumeProc(void)
  3164. ;
  3165.     IF ¬ GENERATINGCFM THEN
  3166.         Macro
  3167.         _LMGetResumeProc     &dest=(sp)
  3168.         move.l               $0A8C,&dest
  3169.         EndM
  3170.     ELSE
  3171.         IMPORT_CFM_FUNCTION    LMGetResumeProc
  3172.     ENDIF
  3173.  
  3174. ;
  3175. ; pascal void LMSetResumeProc(UniversalProcPtr value)
  3176. ;
  3177.     IF ¬ GENERATINGCFM THEN
  3178.         Macro
  3179.         _LMSetResumeProc     &src=(sp)+
  3180.         move.l               &src,$0A8C
  3181.         EndM
  3182.     ELSE
  3183.         IMPORT_CFM_FUNCTION    LMSetResumeProc
  3184.     ENDIF
  3185.  
  3186. ;
  3187. ; pascal SInt16 LMGetANumber(void)
  3188. ;
  3189.     IF ¬ GENERATINGCFM THEN
  3190.         Macro
  3191.         _LMGetANumber        &dest=(sp)
  3192.         move.w               $0A98,&dest
  3193.         EndM
  3194.     ELSE
  3195.         IMPORT_CFM_FUNCTION    LMGetANumber
  3196.     ENDIF
  3197.  
  3198. ;
  3199. ; pascal void LMSetANumber(SInt16 value)
  3200. ;
  3201.     IF ¬ GENERATINGCFM THEN
  3202.         Macro
  3203.         _LMSetANumber        &src=(sp)+
  3204.         move.w               &src,$0A98
  3205.         EndM
  3206.     ELSE
  3207.         IMPORT_CFM_FUNCTION    LMSetANumber
  3208.     ENDIF
  3209.  
  3210. ;
  3211. ; pascal SInt16 LMGetACount(void)
  3212. ;
  3213.     IF ¬ GENERATINGCFM THEN
  3214.         Macro
  3215.         _LMGetACount         &dest=(sp)
  3216.         move.w               $0A9A,&dest
  3217.         EndM
  3218.     ELSE
  3219.         IMPORT_CFM_FUNCTION    LMGetACount
  3220.     ENDIF
  3221.  
  3222. ;
  3223. ; pascal void LMSetACount(SInt16 value)
  3224. ;
  3225.     IF ¬ GENERATINGCFM THEN
  3226.         Macro
  3227.         _LMSetACount         &src=(sp)+
  3228.         move.w               &src,$0A9A
  3229.         EndM
  3230.     ELSE
  3231.         IMPORT_CFM_FUNCTION    LMSetACount
  3232.     ENDIF
  3233.  
  3234. ;
  3235. ; pascal UniversalProcPtr LMGetDABeeper(void)
  3236. ;
  3237.     IF ¬ GENERATINGCFM THEN
  3238.         Macro
  3239.         _LMGetDABeeper       &dest=(sp)
  3240.         move.l               $0A9C,&dest
  3241.         EndM
  3242.     ELSE
  3243.         IMPORT_CFM_FUNCTION    LMGetDABeeper
  3244.     ENDIF
  3245.  
  3246. ;
  3247. ; pascal void LMSetDABeeper(UniversalProcPtr value)
  3248. ;
  3249.     IF ¬ GENERATINGCFM THEN
  3250.         Macro
  3251.         _LMSetDABeeper       &src=(sp)+
  3252.         move.l               &src,$0A9C
  3253.         EndM
  3254.     ELSE
  3255.         IMPORT_CFM_FUNCTION    LMSetDABeeper
  3256.     ENDIF
  3257.  
  3258. ;
  3259. ; pascal UInt16 LMGetTEScrpLength(void)
  3260. ;
  3261.     IF ¬ GENERATINGCFM THEN
  3262.         Macro
  3263.         _LMGetTEScrpLength   &dest=(sp)
  3264.         move.w               $0AB0,&dest
  3265.         EndM
  3266.     ELSE
  3267.         IMPORT_CFM_FUNCTION    LMGetTEScrpLength
  3268.     ENDIF
  3269.  
  3270. ;
  3271. ; pascal void LMSetTEScrpLength(UInt16 value)
  3272. ;
  3273.     IF ¬ GENERATINGCFM THEN
  3274.         Macro
  3275.         _LMSetTEScrpLength   &src=(sp)+
  3276.         move.w               &src,$0AB0
  3277.         EndM
  3278.     ELSE
  3279.         IMPORT_CFM_FUNCTION    LMSetTEScrpLength
  3280.     ENDIF
  3281.  
  3282. ;
  3283. ; pascal Handle LMGetTEScrpHandle(void)
  3284. ;
  3285.     IF ¬ GENERATINGCFM THEN
  3286.         Macro
  3287.         _LMGetTEScrpHandle   &dest=(sp)
  3288.         move.l               $0AB4,&dest
  3289.         EndM
  3290.     ELSE
  3291.         IMPORT_CFM_FUNCTION    LMGetTEScrpHandle
  3292.     ENDIF
  3293.  
  3294. ;
  3295. ; pascal void LMSetTEScrpHandle(Handle value)
  3296. ;
  3297.     IF ¬ GENERATINGCFM THEN
  3298.         Macro
  3299.         _LMSetTEScrpHandle   &src=(sp)+
  3300.         move.l               &src,$0AB4
  3301.         EndM
  3302.     ELSE
  3303.         IMPORT_CFM_FUNCTION    LMSetTEScrpHandle
  3304.     ENDIF
  3305.  
  3306. ;
  3307. ; pascal Handle LMGetAppParmHandle(void)
  3308. ;
  3309.     IF ¬ GENERATINGCFM THEN
  3310.         Macro
  3311.         _LMGetAppParmHandle  &dest=(sp)
  3312.         move.l               $0AEC,&dest
  3313.         EndM
  3314.     ELSE
  3315.         IMPORT_CFM_FUNCTION    LMGetAppParmHandle
  3316.     ENDIF
  3317.  
  3318. ;
  3319. ; pascal void LMSetAppParmHandle(Handle value)
  3320. ;
  3321.     IF ¬ GENERATINGCFM THEN
  3322.         Macro
  3323.         _LMSetAppParmHandle  &src=(sp)+
  3324.         move.l               &src,$0AEC
  3325.         EndM
  3326.     ELSE
  3327.         IMPORT_CFM_FUNCTION    LMSetAppParmHandle
  3328.     ENDIF
  3329.  
  3330. ;
  3331. ; pascal SInt16 LMGetDSErrCode(void)
  3332. ;
  3333.     IF ¬ GENERATINGCFM THEN
  3334.         Macro
  3335.         _LMGetDSErrCode      &dest=(sp)
  3336.         move.w               $0AF0,&dest
  3337.         EndM
  3338.     ELSE
  3339.         IMPORT_CFM_FUNCTION    LMGetDSErrCode
  3340.     ENDIF
  3341.  
  3342. ;
  3343. ; pascal void LMSetDSErrCode(SInt16 value)
  3344. ;
  3345.     IF ¬ GENERATINGCFM THEN
  3346.         Macro
  3347.         _LMSetDSErrCode      &src=(sp)+
  3348.         move.w               &src,$0AF0
  3349.         EndM
  3350.     ELSE
  3351.         IMPORT_CFM_FUNCTION    LMSetDSErrCode
  3352.     ENDIF
  3353.  
  3354. ;
  3355. ; pascal ResErrUPP LMGetResErrProc(void)
  3356. ;
  3357.     IF ¬ GENERATINGCFM THEN
  3358.         Macro
  3359.         _LMGetResErrProc     &dest=(sp)
  3360.         move.l               $0AF2,&dest
  3361.         EndM
  3362.     ELSE
  3363.         IMPORT_CFM_FUNCTION    LMGetResErrProc
  3364.     ENDIF
  3365.  
  3366. ;
  3367. ; pascal void LMSetResErrProc(ResErrUPP value)
  3368. ;
  3369.     IF ¬ GENERATINGCFM THEN
  3370.         Macro
  3371.         _LMSetResErrProc     &src=(sp)+
  3372.         move.l               &src,$0AF2
  3373.         EndM
  3374.     ELSE
  3375.         IMPORT_CFM_FUNCTION    LMSetResErrProc
  3376.     ENDIF
  3377.  
  3378. ;
  3379. ; pascal SInt16 LMGetDlgFont(void)
  3380. ;
  3381.     IF ¬ GENERATINGCFM THEN
  3382.         Macro
  3383.         _LMGetDlgFont        &dest=(sp)
  3384.         move.w               $0AFA,&dest
  3385.         EndM
  3386.     ELSE
  3387.         IMPORT_CFM_FUNCTION    LMGetDlgFont
  3388.     ENDIF
  3389.  
  3390. ;
  3391. ; pascal void LMSetDlgFont(SInt16 value)
  3392. ;
  3393.     IF ¬ GENERATINGCFM THEN
  3394.         Macro
  3395.         _LMSetDlgFont        &src=(sp)+
  3396.         move.w               &src,$0AFA
  3397.         EndM
  3398.     ELSE
  3399.         IMPORT_CFM_FUNCTION    LMSetDlgFont
  3400.     ENDIF
  3401.  
  3402. ;
  3403. ; pascal Handle LMGetROMMapHandle(void)
  3404. ;
  3405.     IF ¬ GENERATINGCFM THEN
  3406.         Macro
  3407.         _LMGetROMMapHandle   &dest=(sp)
  3408.         move.l               $0B06,&dest
  3409.         EndM
  3410.     ELSE
  3411.         IMPORT_CFM_FUNCTION    LMGetROMMapHandle
  3412.     ENDIF
  3413.  
  3414. ;
  3415. ; pascal void LMSetROMMapHandle(Handle value)
  3416. ;
  3417.     IF ¬ GENERATINGCFM THEN
  3418.         Macro
  3419.         _LMSetROMMapHandle   &src=(sp)+
  3420.         move.l               &src,$0B06
  3421.         EndM
  3422.     ELSE
  3423.         IMPORT_CFM_FUNCTION    LMSetROMMapHandle
  3424.     ENDIF
  3425.  
  3426. ;
  3427. ; pascal Ptr LMGetWidthPtr(void)
  3428. ;
  3429.     IF ¬ GENERATINGCFM THEN
  3430.         Macro
  3431.         _LMGetWidthPtr       &dest=(sp)
  3432.         move.l               $0B10,&dest
  3433.         EndM
  3434.     ELSE
  3435.         IMPORT_CFM_FUNCTION    LMGetWidthPtr
  3436.     ENDIF
  3437.  
  3438. ;
  3439. ; pascal void LMSetWidthPtr(Ptr value)
  3440. ;
  3441.     IF ¬ GENERATINGCFM THEN
  3442.         Macro
  3443.         _LMSetWidthPtr       &src=(sp)+
  3444.         move.l               &src,$0B10
  3445.         EndM
  3446.     ELSE
  3447.         IMPORT_CFM_FUNCTION    LMSetWidthPtr
  3448.     ENDIF
  3449.  
  3450. ;
  3451. ; pascal Ptr LMGetATalkHk2(void)
  3452. ;
  3453.     IF ¬ GENERATINGCFM THEN
  3454.         Macro
  3455.         _LMGetATalkHk2       &dest=(sp)
  3456.         move.l               $0B18,&dest
  3457.         EndM
  3458.     ELSE
  3459.         IMPORT_CFM_FUNCTION    LMGetATalkHk2
  3460.     ENDIF
  3461.  
  3462. ;
  3463. ; pascal void LMSetATalkHk2(Ptr value)
  3464. ;
  3465.     IF ¬ GENERATINGCFM THEN
  3466.         Macro
  3467.         _LMSetATalkHk2       &src=(sp)+
  3468.         move.l               &src,$0B18
  3469.         EndM
  3470.     ELSE
  3471.         IMPORT_CFM_FUNCTION    LMSetATalkHk2
  3472.     ENDIF
  3473.  
  3474. ;
  3475. ; pascal SInt16 LMGetHWCfgFlags(void)
  3476. ;
  3477.     IF ¬ GENERATINGCFM THEN
  3478.         Macro
  3479.         _LMGetHWCfgFlags     &dest=(sp)
  3480.         move.w               $0B22,&dest
  3481.         EndM
  3482.     ELSE
  3483.         IMPORT_CFM_FUNCTION    LMGetHWCfgFlags
  3484.     ENDIF
  3485.  
  3486. ;
  3487. ; pascal void LMSetHWCfgFlags(SInt16 value)
  3488. ;
  3489.     IF ¬ GENERATINGCFM THEN
  3490.         Macro
  3491.         _LMSetHWCfgFlags     &src=(sp)+
  3492.         move.w               &src,$0B22
  3493.         EndM
  3494.     ELSE
  3495.         IMPORT_CFM_FUNCTION    LMSetHWCfgFlags
  3496.     ENDIF
  3497.  
  3498. ;
  3499. ; pascal Handle LMGetWidthTabHandle(void)
  3500. ;
  3501.     IF ¬ GENERATINGCFM THEN
  3502.         Macro
  3503.         _LMGetWidthTabHandle &dest=(sp)
  3504.         move.l               $0B2A,&dest
  3505.         EndM
  3506.     ELSE
  3507.         IMPORT_CFM_FUNCTION    LMGetWidthTabHandle
  3508.     ENDIF
  3509.  
  3510. ;
  3511. ; pascal void LMSetWidthTabHandle(Handle value)
  3512. ;
  3513.     IF ¬ GENERATINGCFM THEN
  3514.         Macro
  3515.         _LMSetWidthTabHandle &src=(sp)+
  3516.         move.l               &src,$0B2A
  3517.         EndM
  3518.     ELSE
  3519.         IMPORT_CFM_FUNCTION    LMSetWidthTabHandle
  3520.     ENDIF
  3521.  
  3522. ;
  3523. ; pascal SInt32 LMGetLastSPExtra(void)
  3524. ;
  3525.     IF ¬ GENERATINGCFM THEN
  3526.         Macro
  3527.         _LMGetLastSPExtra    &dest=(sp)
  3528.         move.l               $0B4C,&dest
  3529.         EndM
  3530.     ELSE
  3531.         IMPORT_CFM_FUNCTION    LMGetLastSPExtra
  3532.     ENDIF
  3533.  
  3534. ;
  3535. ; pascal void LMSetLastSPExtra(SInt32 value)
  3536. ;
  3537.     IF ¬ GENERATINGCFM THEN
  3538.         Macro
  3539.         _LMSetLastSPExtra    &src=(sp)+
  3540.         move.l               &src,$0B4C
  3541.         EndM
  3542.     ELSE
  3543.         IMPORT_CFM_FUNCTION    LMSetLastSPExtra
  3544.     ENDIF
  3545.  
  3546. ;
  3547. ; pascal SInt32 LMGetMenuDisable(void)
  3548. ;
  3549.     IF ¬ GENERATINGCFM THEN
  3550.         Macro
  3551.         _LMGetMenuDisable    &dest=(sp)
  3552.         move.l               $0B54,&dest
  3553.         EndM
  3554.     ELSE
  3555.         IMPORT_CFM_FUNCTION    LMGetMenuDisable
  3556.     ENDIF
  3557.  
  3558. ;
  3559. ; pascal void LMSetMenuDisable(SInt32 value)
  3560. ;
  3561.     IF ¬ GENERATINGCFM THEN
  3562.         Macro
  3563.         _LMSetMenuDisable    &src=(sp)+
  3564.         move.l               &src,$0B54
  3565.         EndM
  3566.     ELSE
  3567.         IMPORT_CFM_FUNCTION    LMSetMenuDisable
  3568.     ENDIF
  3569.  
  3570. ;
  3571. ; pascal UInt8 LMGetROMMapInsert(void)
  3572. ;
  3573.     IF ¬ GENERATINGCFM THEN
  3574.         Macro
  3575.         _LMGetROMMapInsert   &dest=(sp)
  3576.         move.b               $0B9E,&dest
  3577.         EndM
  3578.     ELSE
  3579.         IMPORT_CFM_FUNCTION    LMGetROMMapInsert
  3580.     ENDIF
  3581.  
  3582. ;
  3583. ; pascal void LMSetROMMapInsert(UInt8 value)
  3584. ;
  3585.     IF ¬ GENERATINGCFM THEN
  3586.         Macro
  3587.         _LMSetROMMapInsert   &src=(sp)+
  3588.         move.b               &src,$0B9E
  3589.         EndM
  3590.     ELSE
  3591.         IMPORT_CFM_FUNCTION    LMSetROMMapInsert
  3592.     ENDIF
  3593.  
  3594. ;
  3595. ; pascal UInt8 LMGetTmpResLoad(void)
  3596. ;
  3597.     IF ¬ GENERATINGCFM THEN
  3598.         Macro
  3599.         _LMGetTmpResLoad     &dest=(sp)
  3600.         move.b               $0B9F,&dest
  3601.         EndM
  3602.     ELSE
  3603.         IMPORT_CFM_FUNCTION    LMGetTmpResLoad
  3604.     ENDIF
  3605.  
  3606. ;
  3607. ; pascal void LMSetTmpResLoad(UInt8 value)
  3608. ;
  3609.     IF ¬ GENERATINGCFM THEN
  3610.         Macro
  3611.         _LMSetTmpResLoad     &src=(sp)+
  3612.         move.b               &src,$0B9F
  3613.         EndM
  3614.     ELSE
  3615.         IMPORT_CFM_FUNCTION    LMSetTmpResLoad
  3616.     ENDIF
  3617.  
  3618. ;
  3619. ; pascal Ptr LMGetIntlSpec(void)
  3620. ;
  3621.     IF ¬ GENERATINGCFM THEN
  3622.         Macro
  3623.         _LMGetIntlSpec       &dest=(sp)
  3624.         move.l               $0BA0,&dest
  3625.         EndM
  3626.     ELSE
  3627.         IMPORT_CFM_FUNCTION    LMGetIntlSpec
  3628.     ENDIF
  3629.  
  3630. ;
  3631. ; pascal void LMSetIntlSpec(Ptr value)
  3632. ;
  3633.     IF ¬ GENERATINGCFM THEN
  3634.         Macro
  3635.         _LMSetIntlSpec       &src=(sp)+
  3636.         move.l               &src,$0BA0
  3637.         EndM
  3638.     ELSE
  3639.         IMPORT_CFM_FUNCTION    LMSetIntlSpec
  3640.     ENDIF
  3641.  
  3642. ;
  3643. ; pascal UInt8 LMGetWordRedraw(void)
  3644. ;
  3645.     IF ¬ GENERATINGCFM THEN
  3646.         Macro
  3647.         _LMGetWordRedraw     &dest=(sp)
  3648.         move.b               $0BA5,&dest
  3649.         EndM
  3650.     ELSE
  3651.         IMPORT_CFM_FUNCTION    LMGetWordRedraw
  3652.     ENDIF
  3653.  
  3654. ;
  3655. ; pascal void LMSetWordRedraw(UInt8 value)
  3656. ;
  3657.     IF ¬ GENERATINGCFM THEN
  3658.         Macro
  3659.         _LMSetWordRedraw     &src=(sp)+
  3660.         move.b               &src,$0BA5
  3661.         EndM
  3662.     ELSE
  3663.         IMPORT_CFM_FUNCTION    LMSetWordRedraw
  3664.     ENDIF
  3665.  
  3666. ;
  3667. ; pascal SInt16 LMGetSysFontFam(void)
  3668. ;
  3669.     IF ¬ GENERATINGCFM THEN
  3670.         Macro
  3671.         _LMGetSysFontFam     &dest=(sp)
  3672.         move.w               $0BA6,&dest
  3673.         EndM
  3674.     ELSE
  3675.         IMPORT_CFM_FUNCTION    LMGetSysFontFam
  3676.     ENDIF
  3677.  
  3678. ;
  3679. ; pascal void LMSetSysFontFam(SInt16 value)
  3680. ;
  3681.     IF ¬ GENERATINGCFM THEN
  3682.         Macro
  3683.         _LMSetSysFontFam     &src=(sp)+
  3684.         move.w               &src,$0BA6
  3685.         EndM
  3686.     ELSE
  3687.         IMPORT_CFM_FUNCTION    LMSetSysFontFam
  3688.     ENDIF
  3689.  
  3690. ;
  3691. ; pascal SInt16 LMGetSysFontSize(void)
  3692. ;
  3693.     IF ¬ GENERATINGCFM THEN
  3694.         Macro
  3695.         _LMGetSysFontSize    &dest=(sp)
  3696.         move.w               $0BA8,&dest
  3697.         EndM
  3698.     ELSE
  3699.         IMPORT_CFM_FUNCTION    LMGetSysFontSize
  3700.     ENDIF
  3701.  
  3702. ;
  3703. ; pascal void LMSetSysFontSize(SInt16 value)
  3704. ;
  3705.     IF ¬ GENERATINGCFM THEN
  3706.         Macro
  3707.         _LMSetSysFontSize    &src=(sp)+
  3708.         move.w               &src,$0BA8
  3709.         EndM
  3710.     ELSE
  3711.         IMPORT_CFM_FUNCTION    LMSetSysFontSize
  3712.     ENDIF
  3713.  
  3714. ;
  3715. ; pascal SInt16 LMGetMBarHeight(void)
  3716. ;
  3717.     IF ¬ GENERATINGCFM THEN
  3718.         Macro
  3719.         _LMGetMBarHeight     &dest=(sp)
  3720.         move.w               $0BAA,&dest
  3721.         EndM
  3722.     ELSE
  3723.         IMPORT_CFM_FUNCTION    LMGetMBarHeight
  3724.     ENDIF
  3725.  
  3726. ;
  3727. ; pascal void LMSetMBarHeight(SInt16 value)
  3728. ;
  3729.     IF ¬ GENERATINGCFM THEN
  3730.         Macro
  3731.         _LMSetMBarHeight     &src=(sp)+
  3732.         move.w               &src,$0BAA
  3733.         EndM
  3734.     ELSE
  3735.         IMPORT_CFM_FUNCTION    LMSetMBarHeight
  3736.     ENDIF
  3737.  
  3738. ;
  3739. ; pascal SInt16 LMGetTESysJust(void)
  3740. ;
  3741.     IF ¬ GENERATINGCFM THEN
  3742.         Macro
  3743.         _LMGetTESysJust      &dest=(sp)
  3744.         move.w               $0BAC,&dest
  3745.         EndM
  3746.     ELSE
  3747.         IMPORT_CFM_FUNCTION    LMGetTESysJust
  3748.     ENDIF
  3749.  
  3750. ;
  3751. ; pascal void LMSetTESysJust(SInt16 value)
  3752. ;
  3753.     IF ¬ GENERATINGCFM THEN
  3754.         Macro
  3755.         _LMSetTESysJust      &src=(sp)+
  3756.         move.w               &src,$0BAC
  3757.         EndM
  3758.     ELSE
  3759.         IMPORT_CFM_FUNCTION    LMSetTESysJust
  3760.     ENDIF
  3761.  
  3762. ;
  3763. ; pascal Ptr LMGetHighHeapMark(void)
  3764. ;
  3765.     IF ¬ GENERATINGCFM THEN
  3766.         Macro
  3767.         _LMGetHighHeapMark   &dest=(sp)
  3768.         move.l               $0BAE,&dest
  3769.         EndM
  3770.     ELSE
  3771.         IMPORT_CFM_FUNCTION    LMGetHighHeapMark
  3772.     ENDIF
  3773.  
  3774. ;
  3775. ; pascal void LMSetHighHeapMark(Ptr value)
  3776. ;
  3777.     IF ¬ GENERATINGCFM THEN
  3778.         Macro
  3779.         _LMSetHighHeapMark   &src=(sp)+
  3780.         move.l               &src,$0BAE
  3781.         EndM
  3782.     ELSE
  3783.         IMPORT_CFM_FUNCTION    LMSetHighHeapMark
  3784.     ENDIF
  3785.  
  3786. ;
  3787. ; pascal Handle LMGetLastFOND(void)
  3788. ;
  3789.     IF ¬ GENERATINGCFM THEN
  3790.         Macro
  3791.         _LMGetLastFOND       &dest=(sp)
  3792.         move.l               $0BC2,&dest
  3793.         EndM
  3794.     ELSE
  3795.         IMPORT_CFM_FUNCTION    LMGetLastFOND
  3796.     ENDIF
  3797.  
  3798. ;
  3799. ; pascal void LMSetLastFOND(Handle value)
  3800. ;
  3801.     IF ¬ GENERATINGCFM THEN
  3802.         Macro
  3803.         _LMSetLastFOND       &src=(sp)+
  3804.         move.l               &src,$0BC2
  3805.         EndM
  3806.     ELSE
  3807.         IMPORT_CFM_FUNCTION    LMSetLastFOND
  3808.     ENDIF
  3809.  
  3810. ;
  3811. ; pascal UInt8 LMGetFractEnable(void)
  3812. ;
  3813.     IF ¬ GENERATINGCFM THEN
  3814.         Macro
  3815.         _LMGetFractEnable    &dest=(sp)
  3816.         move.b               $0BF4,&dest
  3817.         EndM
  3818.     ELSE
  3819.         IMPORT_CFM_FUNCTION    LMGetFractEnable
  3820.     ENDIF
  3821.  
  3822. ;
  3823. ; pascal void LMSetFractEnable(UInt8 value)
  3824. ;
  3825.     IF ¬ GENERATINGCFM THEN
  3826.         Macro
  3827.         _LMSetFractEnable    &src=(sp)+
  3828.         move.b               &src,$0BF4
  3829.         EndM
  3830.     ELSE
  3831.         IMPORT_CFM_FUNCTION    LMSetFractEnable
  3832.     ENDIF
  3833.  
  3834. ;
  3835. ; pascal UInt8 LMGetMMU32Bit(void)
  3836. ;
  3837.     IF ¬ GENERATINGCFM THEN
  3838.         Macro
  3839.         _LMGetMMU32Bit       &dest=(sp)
  3840.         move.b               $0CB2,&dest
  3841.         EndM
  3842.     ELSE
  3843.         IMPORT_CFM_FUNCTION    LMGetMMU32Bit
  3844.     ENDIF
  3845.  
  3846. ;
  3847. ; pascal void LMSetMMU32Bit(UInt8 value)
  3848. ;
  3849.     IF ¬ GENERATINGCFM THEN
  3850.         Macro
  3851.         _LMSetMMU32Bit       &src=(sp)+
  3852.         move.b               &src,$0CB2
  3853.         EndM
  3854.     ELSE
  3855.         IMPORT_CFM_FUNCTION    LMSetMMU32Bit
  3856.     ENDIF
  3857.  
  3858. ;
  3859. ; pascal GDHandle LMGetTheGDevice(void)
  3860. ;
  3861.     IF ¬ GENERATINGCFM THEN
  3862.         Macro
  3863.         _LMGetTheGDevice     &dest=(sp)
  3864.         move.l               $0CC8,&dest
  3865.         EndM
  3866.     ELSE
  3867.         IMPORT_CFM_FUNCTION    LMGetTheGDevice
  3868.     ENDIF
  3869.  
  3870. ;
  3871. ; pascal void LMSetTheGDevice(GDHandle value)
  3872. ;
  3873.     IF ¬ GENERATINGCFM THEN
  3874.         Macro
  3875.         _LMSetTheGDevice     &src=(sp)+
  3876.         move.l               &src,$0CC8
  3877.         EndM
  3878.     ELSE
  3879.         IMPORT_CFM_FUNCTION    LMSetTheGDevice
  3880.     ENDIF
  3881.  
  3882. ;
  3883. ; pascal PixPatHandle LMGetDeskCPat(void)
  3884. ;
  3885.     IF ¬ GENERATINGCFM THEN
  3886.         Macro
  3887.         _LMGetDeskCPat       &dest=(sp)
  3888.         move.l               $0CD8,&dest
  3889.         EndM
  3890.     ELSE
  3891.         IMPORT_CFM_FUNCTION    LMGetDeskCPat
  3892.     ENDIF
  3893.  
  3894. ;
  3895. ; pascal void LMSetDeskCPat(PixPatHandle value)
  3896. ;
  3897.     IF ¬ GENERATINGCFM THEN
  3898.         Macro
  3899.         _LMSetDeskCPat       &src=(sp)+
  3900.         move.l               &src,$0CD8
  3901.         EndM
  3902.     ELSE
  3903.         IMPORT_CFM_FUNCTION    LMSetDeskCPat
  3904.     ENDIF
  3905.  
  3906. ;
  3907. ; pascal SInt16 LMGetTimeDBRA(void)
  3908. ;
  3909.     IF ¬ GENERATINGCFM THEN
  3910.         Macro
  3911.         _LMGetTimeDBRA       &dest=(sp)
  3912.         move.w               $0D00,&dest
  3913.         EndM
  3914.     ELSE
  3915.         IMPORT_CFM_FUNCTION    LMGetTimeDBRA
  3916.     ENDIF
  3917.  
  3918. ;
  3919. ; pascal void LMSetTimeDBRA(SInt16 value)
  3920. ;
  3921.     IF ¬ GENERATINGCFM THEN
  3922.         Macro
  3923.         _LMSetTimeDBRA       &src=(sp)+
  3924.         move.w               &src,$0D00
  3925.         EndM
  3926.     ELSE
  3927.         IMPORT_CFM_FUNCTION    LMSetTimeDBRA
  3928.     ENDIF
  3929.  
  3930. ;
  3931. ; pascal SInt16 LMGetTimeSCCDB(void)
  3932. ;
  3933.     IF ¬ GENERATINGCFM THEN
  3934.         Macro
  3935.         _LMGetTimeSCCDB      &dest=(sp)
  3936.         move.w               $0D02,&dest
  3937.         EndM
  3938.     ELSE
  3939.         IMPORT_CFM_FUNCTION    LMGetTimeSCCDB
  3940.     ENDIF
  3941.  
  3942. ;
  3943. ; pascal void LMSetTimeSCCDB(SInt16 value)
  3944. ;
  3945.     IF ¬ GENERATINGCFM THEN
  3946.         Macro
  3947.         _LMSetTimeSCCDB      &src=(sp)+
  3948.         move.w               &src,$0D02
  3949.         EndM
  3950.     ELSE
  3951.         IMPORT_CFM_FUNCTION    LMSetTimeSCCDB
  3952.     ENDIF
  3953.  
  3954. ;
  3955. ; pascal UniversalProcPtr LMGetJVBLTask(void)
  3956. ;
  3957.     IF ¬ GENERATINGCFM THEN
  3958.         Macro
  3959.         _LMGetJVBLTask       &dest=(sp)
  3960.         move.l               $0D28,&dest
  3961.         EndM
  3962.     ELSE
  3963.         IMPORT_CFM_FUNCTION    LMGetJVBLTask
  3964.     ENDIF
  3965.  
  3966. ;
  3967. ; pascal void LMSetJVBLTask(UniversalProcPtr value)
  3968. ;
  3969.     IF ¬ GENERATINGCFM THEN
  3970.         Macro
  3971.         _LMSetJVBLTask       &src=(sp)+
  3972.         move.l               &src,$0D28
  3973.         EndM
  3974.     ELSE
  3975.         IMPORT_CFM_FUNCTION    LMSetJVBLTask
  3976.     ENDIF
  3977.  
  3978. ;
  3979. ; pascal Handle LMGetSynListHandle(void)
  3980. ;
  3981.     IF ¬ GENERATINGCFM THEN
  3982.         Macro
  3983.         _LMGetSynListHandle  &dest=(sp)
  3984.         move.l               $0D32,&dest
  3985.         EndM
  3986.     ELSE
  3987.         IMPORT_CFM_FUNCTION    LMGetSynListHandle
  3988.     ENDIF
  3989.  
  3990. ;
  3991. ; pascal void LMSetSynListHandle(Handle value)
  3992. ;
  3993.     IF ¬ GENERATINGCFM THEN
  3994.         Macro
  3995.         _LMSetSynListHandle  &src=(sp)+
  3996.         move.l               &src,$0D32
  3997.         EndM
  3998.     ELSE
  3999.         IMPORT_CFM_FUNCTION    LMSetSynListHandle
  4000.     ENDIF
  4001.  
  4002. ;
  4003. ; pascal MCTableHandle LMGetMenuCInfo(void)
  4004. ;
  4005.     IF ¬ GENERATINGCFM THEN
  4006.         Macro
  4007.         _LMGetMenuCInfo      &dest=(sp)
  4008.         move.l               $0D50,&dest
  4009.         EndM
  4010.     ELSE
  4011.         IMPORT_CFM_FUNCTION    LMGetMenuCInfo
  4012.     ENDIF
  4013.  
  4014. ;
  4015. ; pascal void LMSetMenuCInfo(MCTableHandle value)
  4016. ;
  4017.     IF ¬ GENERATINGCFM THEN
  4018.         Macro
  4019.         _LMSetMenuCInfo      &src=(sp)+
  4020.         move.l               &src,$0D50
  4021.         EndM
  4022.     ELSE
  4023.         IMPORT_CFM_FUNCTION    LMSetMenuCInfo
  4024.     ENDIF
  4025.  
  4026. ;
  4027. ; pascal UniversalProcPtr LMGetJDTInstall(void)
  4028. ;
  4029.     IF ¬ GENERATINGCFM THEN
  4030.         Macro
  4031.         _LMGetJDTInstall     &dest=(sp)
  4032.         move.l               $0D9C,&dest
  4033.         EndM
  4034.     ELSE
  4035.         IMPORT_CFM_FUNCTION    LMGetJDTInstall
  4036.     ENDIF
  4037.  
  4038. ;
  4039. ; pascal void LMSetJDTInstall(UniversalProcPtr value)
  4040. ;
  4041.     IF ¬ GENERATINGCFM THEN
  4042.         Macro
  4043.         _LMSetJDTInstall     &src=(sp)+
  4044.         move.l               &src,$0D9C
  4045.         EndM
  4046.     ELSE
  4047.         IMPORT_CFM_FUNCTION    LMSetJDTInstall
  4048.     ENDIF
  4049.  
  4050. ;
  4051. ; pascal SInt16 LMGetTimeSCSIDB(void)
  4052. ;
  4053.     IF ¬ GENERATINGCFM THEN
  4054.         Macro
  4055.         _LMGetTimeSCSIDB     &dest=(sp)
  4056.         move.w               $0B24,&dest
  4057.         EndM
  4058.     ELSE
  4059.         IMPORT_CFM_FUNCTION    LMGetTimeSCSIDB
  4060.     ENDIF
  4061.  
  4062. ;
  4063. ; pascal void LMSetTimeSCSIDB(SInt16 value)
  4064. ;
  4065.     IF ¬ GENERATINGCFM THEN
  4066.         Macro
  4067.         _LMSetTimeSCSIDB     &src=(sp)+
  4068.         move.w               &src,$0B24
  4069.         EndM
  4070.     ELSE
  4071.         IMPORT_CFM_FUNCTION    LMSetTimeSCSIDB
  4072.     ENDIF
  4073.  
  4074. ;*************************************************************************************
  4075. ;
  4076. ;    MORE COMPLEX LOWMEM ACCESSORS
  4077. ;
  4078. ;*************************************************************************************
  4079.     IF CFMSYSTEMCALLS  THEN
  4080. ;
  4081. ; pascal void LMGetDSAlertRect(Rect *dsAlertRectValue)
  4082. ;
  4083.     IF GENERATINGCFM THEN
  4084.         IMPORT_CFM_FUNCTION    LMGetDSAlertRect
  4085.     ENDIF
  4086.  
  4087. ;
  4088. ; pascal void LMSetDSAlertRect(const Rect *dsAlertRectValue)
  4089. ;
  4090.     IF GENERATINGCFM THEN
  4091.         IMPORT_CFM_FUNCTION    LMSetDSAlertRect
  4092.     ENDIF
  4093.  
  4094. ;
  4095. ; pascal void LMGetDragPattern(Pattern *dragPatternValue)
  4096. ;
  4097.     IF GENERATINGCFM THEN
  4098.         IMPORT_CFM_FUNCTION    LMGetDragPattern
  4099.     ENDIF
  4100.  
  4101. ;
  4102. ; pascal void LMSetDragPattern(const Pattern *dragPatternValue)
  4103. ;
  4104.     IF GENERATINGCFM THEN
  4105.         IMPORT_CFM_FUNCTION    LMSetDragPattern
  4106.     ENDIF
  4107.  
  4108. ;
  4109. ; pascal void LMGetDeskPattern(Pattern *deskPatternValue)
  4110. ;
  4111.     IF GENERATINGCFM THEN
  4112.         IMPORT_CFM_FUNCTION    LMGetDeskPattern
  4113.     ENDIF
  4114.  
  4115. ;
  4116. ; pascal void LMSetDeskPattern(const Pattern *deskPatternValue)
  4117. ;
  4118.     IF GENERATINGCFM THEN
  4119.         IMPORT_CFM_FUNCTION    LMSetDeskPattern
  4120.     ENDIF
  4121.  
  4122. ;
  4123. ; pascal void LMGetHiliteRGB(RGBColor *hiliteRGBValue)
  4124. ;
  4125.     IF GENERATINGCFM THEN
  4126.         IMPORT_CFM_FUNCTION    LMGetHiliteRGB
  4127.     ENDIF
  4128.  
  4129. ;
  4130. ; pascal void LMSetHiliteRGB(const RGBColor *hiliteRGBValue)
  4131. ;
  4132.     IF GENERATINGCFM THEN
  4133.         IMPORT_CFM_FUNCTION    LMSetHiliteRGB
  4134.     ENDIF
  4135.  
  4136. ;
  4137. ; pascal QHdrPtr LMGetEventQueue(void)
  4138. ;
  4139.     IF GENERATINGCFM THEN
  4140.         IMPORT_CFM_FUNCTION    LMGetEventQueue
  4141.     ENDIF
  4142.  
  4143. ;
  4144. ; pascal void LMSetEventQueue(QHdrPtr eventQueueValue)
  4145. ;
  4146.     IF GENERATINGCFM THEN
  4147.         IMPORT_CFM_FUNCTION    LMSetEventQueue
  4148.     ENDIF
  4149.  
  4150. ;
  4151. ; pascal QHdrPtr LMGetVBLQueue(void)
  4152. ;
  4153.     IF GENERATINGCFM THEN
  4154.         IMPORT_CFM_FUNCTION    LMGetVBLQueue
  4155.     ENDIF
  4156.  
  4157. ;
  4158. ; pascal void LMSetVBLQueue(QHdrPtr vblQueueValue)
  4159. ;
  4160.     IF GENERATINGCFM THEN
  4161.         IMPORT_CFM_FUNCTION    LMSetVBLQueue
  4162.     ENDIF
  4163.  
  4164. ;
  4165. ; pascal QHdrPtr LMGetDrvQHdr(void)
  4166. ;
  4167.     IF GENERATINGCFM THEN
  4168.         IMPORT_CFM_FUNCTION    LMGetDrvQHdr
  4169.     ENDIF
  4170.  
  4171. ;
  4172. ; pascal void LMSetDrvQHdr(QHdrPtr drvQHdrValue)
  4173. ;
  4174.     IF GENERATINGCFM THEN
  4175.         IMPORT_CFM_FUNCTION    LMSetDrvQHdr
  4176.     ENDIF
  4177.  
  4178. ;
  4179. ; pascal QHdrPtr LMGetVCBQHdr(void)
  4180. ;
  4181.     IF GENERATINGCFM THEN
  4182.         IMPORT_CFM_FUNCTION    LMGetVCBQHdr
  4183.     ENDIF
  4184.  
  4185. ;
  4186. ; pascal void LMSetVCBQHdr(QHdrPtr vcbQHdrValue)
  4187. ;
  4188.     IF GENERATINGCFM THEN
  4189.         IMPORT_CFM_FUNCTION    LMSetVCBQHdr
  4190.     ENDIF
  4191.  
  4192. ;
  4193. ; pascal QHdrPtr LMGetDTQueue(void)
  4194. ;
  4195.     IF GENERATINGCFM THEN
  4196.         IMPORT_CFM_FUNCTION    LMGetDTQueue
  4197.     ENDIF
  4198.  
  4199. ;
  4200. ; pascal void LMSetDTQueue(QHdrPtr dtQueueValue)
  4201. ;
  4202.     IF GENERATINGCFM THEN
  4203.         IMPORT_CFM_FUNCTION    LMSetDTQueue
  4204.     ENDIF
  4205.  
  4206. ;
  4207. ; pascal QHdrPtr LMGetFSQHdr(void)
  4208. ;
  4209.     IF GENERATINGCFM THEN
  4210.         IMPORT_CFM_FUNCTION    LMGetFSQHdr
  4211.     ENDIF
  4212.  
  4213. ;*************************************************************************************
  4214. ;    "BLOCKMOVE ACCESSORS"
  4215. ;    
  4216. ;        These lowmem accessors use the BlockMove trap
  4217. ;*************************************************************************************
  4218. ;
  4219. ; pascal StringPtr LMGetCurApName(void)
  4220. ;
  4221.     IF GENERATINGCFM THEN
  4222.         IMPORT_CFM_FUNCTION    LMGetCurApName
  4223.     ENDIF
  4224.  
  4225. ;
  4226. ; pascal void LMSetCurApName(ConstStr31Param curApNameValue)
  4227. ;
  4228.     IF GENERATINGCFM THEN
  4229.         IMPORT_CFM_FUNCTION    LMSetCurApName
  4230.     ENDIF
  4231.  
  4232. ;
  4233. ; pascal StringPtr LMGetSysResName(void)
  4234. ;
  4235.     IF GENERATINGCFM THEN
  4236.         IMPORT_CFM_FUNCTION    LMGetSysResName
  4237.     ENDIF
  4238.  
  4239. ;
  4240. ; pascal void LMSetSysResName(ConstStr15Param sysResNameValue)
  4241. ;
  4242.     IF GENERATINGCFM THEN
  4243.         IMPORT_CFM_FUNCTION    LMSetSysResName
  4244.     ENDIF
  4245.  
  4246. ;
  4247. ; pascal StringPtr LMGetFinderName(void)
  4248. ;
  4249.     IF GENERATINGCFM THEN
  4250.         IMPORT_CFM_FUNCTION    LMGetFinderName
  4251.     ENDIF
  4252.  
  4253. ;
  4254. ; pascal void LMSetFinderName(ConstStr15Param finderNameValue)
  4255. ;
  4256.     IF GENERATINGCFM THEN
  4257.         IMPORT_CFM_FUNCTION    LMSetFinderName
  4258.     ENDIF
  4259.  
  4260. ;
  4261. ; pascal Ptr LMGetABusVars(void)
  4262. ;
  4263.     IF GENERATINGCFM THEN
  4264.         IMPORT_CFM_FUNCTION    LMGetABusVars
  4265.     ENDIF
  4266.  
  4267. ;
  4268. ; pascal void LMSetABusVars(Ptr aBusVarsValue)
  4269. ;
  4270.     IF GENERATINGCFM THEN
  4271.         IMPORT_CFM_FUNCTION    LMSetABusVars
  4272.     ENDIF
  4273.  
  4274. ;
  4275. ; pascal Ptr LMGetScratch20(void)
  4276. ;
  4277.     IF GENERATINGCFM THEN
  4278.         IMPORT_CFM_FUNCTION    LMGetScratch20
  4279.     ENDIF
  4280.  
  4281. ;
  4282. ; pascal void LMSetScratch20(const void *scratch20Value)
  4283. ;
  4284.     IF GENERATINGCFM THEN
  4285.         IMPORT_CFM_FUNCTION    LMSetScratch20
  4286.     ENDIF
  4287.  
  4288. ;
  4289. ; pascal Ptr LMGetToolScratch(void)
  4290. ;
  4291.     IF GENERATINGCFM THEN
  4292.         IMPORT_CFM_FUNCTION    LMGetToolScratch
  4293.     ENDIF
  4294.  
  4295. ;
  4296. ; pascal void LMSetToolScratch(const void *toolScratchValue)
  4297. ;
  4298.     IF GENERATINGCFM THEN
  4299.         IMPORT_CFM_FUNCTION    LMSetToolScratch
  4300.     ENDIF
  4301.  
  4302. ;
  4303. ; pascal Ptr LMGetApplScratch(void)
  4304. ;
  4305.     IF GENERATINGCFM THEN
  4306.         IMPORT_CFM_FUNCTION    LMGetApplScratch
  4307.     ENDIF
  4308.  
  4309. ;
  4310. ; pascal void LMSetApplScratch(const void *applScratchValue)
  4311. ;
  4312.     IF GENERATINGCFM THEN
  4313.         IMPORT_CFM_FUNCTION    LMSetApplScratch
  4314.     ENDIF
  4315.  
  4316. ;*************************************************************************************
  4317. ;    "INDEXED ACCESSORS"
  4318. ;    
  4319. ;        These lowmem accessors take an index parameter to get/set an indexed
  4320. ;        lowmem global.
  4321. ;*************************************************************************************
  4322. ;
  4323. ; pascal StringHandle LMGetDAStrings(short whichString)
  4324. ;
  4325.     IF GENERATINGCFM THEN
  4326.         IMPORT_CFM_FUNCTION    LMGetDAStrings
  4327.     ENDIF
  4328.  
  4329. ;
  4330. ; pascal void LMSetDAStrings(StringHandle stringsValue, short whichString)
  4331. ;
  4332.     IF GENERATINGCFM THEN
  4333.         IMPORT_CFM_FUNCTION    LMSetDAStrings
  4334.     ENDIF
  4335.  
  4336. ;
  4337. ; pascal UniversalProcPtr LMGetLvl2DT(short vectorNumber)
  4338. ;
  4339.     IF GENERATINGCFM THEN
  4340.         IMPORT_CFM_FUNCTION    LMGetLvl2DT
  4341.     ENDIF
  4342.  
  4343. ;
  4344. ; pascal void LMSetLvl2DT(UniversalProcPtr Lvl2DTValue, short vectorNumber)
  4345. ;
  4346.     IF GENERATINGCFM THEN
  4347.         IMPORT_CFM_FUNCTION    LMSetLvl2DT
  4348.     ENDIF
  4349.  
  4350. ;
  4351. ; pascal UniversalProcPtr LMGetExtStsDT(short vectorNumber)
  4352. ;
  4353.     IF GENERATINGCFM THEN
  4354.         IMPORT_CFM_FUNCTION    LMGetExtStsDT
  4355.     ENDIF
  4356.  
  4357. ;
  4358. ; pascal void LMSetExtStsDT(UniversalProcPtr ExtStsDTValue, short vectorNumber)
  4359. ;
  4360.     IF GENERATINGCFM THEN
  4361.         IMPORT_CFM_FUNCTION    LMSetExtStsDT
  4362.     ENDIF
  4363.  
  4364.     ENDIF
  4365.     ENDIF ; __LOWMEM__
  4366.